Release 1.0.1.0

Also remove stack.yaml since it isn't used anymore. and adding libraries
to the snapshots doesn't seem to be as easy as I hoped.

CHANGELOG.md

@@ -6,6 +6,65 @@ The format is based on
 and this project adheres to
 [Haskell Package Versioning Policy](https://pvp.haskell.org/).
 
+## [1.0.1.0] - 2021-09-27
+### Added
+- Custom `Show` instance for `Type.Definition.Value` (for error
+  messages).
+- Path information in errors (path to the field throwing the error).
+- Deprecation notes in the `Error` module for `Resolution`, `CollectErrsT` and
+  `runCollectErrs`. These symbols are part of the old executor and aren't used
+  anymore, it will be deprecated in the future and removed.
+- `TH` module with the `gql` quasi quoter.
+
+### Fixed
+- Error messages are more concrete, they also contain type information and
+  wrong values, where appropriate and possible.
+- If the field with an error is Non-Nullable, the error is propagated to the
+  first nullable field, as required by the specification.
+
+## [1.0.0.0] - 2021-07-04
+### Added
+- `Language.GraphQL.Execute.OrderedMap` is a map data structure, that preserves
+  insertion order.
+- `Language.GraphQL.Schema.schemaWithTypes` constructs a complete schema,
+  including an optional schema description and user-defined types not referenced
+  in the schema directly (for example interface implementations).
+- `Language.GraphQL.Schema.description` returns the optional schema description.
+- All errors that can be associated with a location in the query contain
+  location information.
+
+### Fixed
+- Parser now accepts empty lists and objects.
+- Parser now accepts all directive locations.
+- `valuesOfCorrectTypeRule` doesn't check lists recursively since the
+  validation traverser calls it on all list items.
+- `valuesOfCorrectTypeRule` doesn't check objects recursively since the
+  validation traverser calls it on all object properties.
+- Validation of non-nullable values inside lists.
+- `executeField` shouldn't assume that a selection has only one field with a
+  given name, but it should take the first field. The underlying cause is a
+  wrong pattern, which (because of the laziness) is executed only if the field
+  has arguments.
+
+### Changed
+- `AST.Document.Value.List` and `AST.Document.ConstValue.ConstList` contain
+  location information for each list item.
+- `Error`: `singleError`, `addErr` and `addErrMsg` are deprecated. They are
+  internal functions used by the executor for error handling.
+
+## [0.11.1.0] - 2021-02-07
+### Added
+- `Validate.Rules`:
+  - `overlappingFieldsCanBeMergedRule`
+  - `possibleFragmentSpreadsRule`
+  - `variablesInAllowedPositionRule`
+  - `valuesOfCorrectTypeRule`
+- `Type.Schema.implementations` contains a map from interfaces and objects to
+  interfaces they implement.
+- Show instances for GraphQL type definitions in the `Type` modules.
+- Custom Show instances for type and value representations in the AST.
+- `AST.Document.escape` escapes a single character in a `StringValue`.
+
 ## [0.11.0.0] - 2020-11-07
 ### Changed
 - `AST.Document.Selection` wraps additional new types: `Field`, `FragmentSpread`
@@ -400,6 +459,9 @@ and this project adheres to
 ### Added
 - Data types for the GraphQL language.
 
+[1.0.1.0]: https://www.caraus.tech/projects/pub-graphql/repository/23/diff?rev=v1.0.1.0&rev_to=v1.0.0.0
+[1.0.0.0]: https://www.caraus.tech/projects/pub-graphql/repository/23/diff?rev=v1.0.0.0&rev_to=v0.11.1.0
+[0.11.1.0]: https://www.caraus.tech/projects/pub-graphql/repository/23/diff?rev=v0.11.1.0&rev_to=v0.11.0.0
 [0.11.0.0]: https://www.caraus.tech/projects/pub-graphql/repository/23/diff?rev=v0.11.0.0&rev_to=v0.10.0.0
 [0.10.0.0]: https://www.caraus.tech/projects/pub-graphql/repository/23/diff?rev=v0.10.0.0&rev_to=v0.9.0.0
 [0.9.0.0]: https://www.caraus.tech/projects/pub-graphql/repository/23/diff?rev=v0.9.0.0&rev_to=v0.8.0.0

README.md

@@ -3,29 +3,10 @@
 [![Simple Haskell](https://www.simplehaskell.org/badges/badge.svg)](https://www.simplehaskell.org)
 [![CI/CD](https://img.shields.io/badge/CI-CD-brightgreen)](https://build.caraus.tech/go/pipelines)
 
-This implementation is relatively low-level by design, it doesn't provide any
+See https://www.caraus.tech/projects/pub-graphql.
-mappings between the GraphQL types and Haskell's type system and avoids
-compile-time magic. It focuses on flexibility instead, so other solutions can
-be built on top of it.
 
-## State of the work
+Report issues on the
-
+[bug tracker](https://www.caraus.tech/projects/pub-graphql/issues).
-For now this library provides:
-
-- Parser for the query and schema languages, as well as a printer for the query
-  language (minimizer and pretty-printer).
-- Data structures to define a type system.
-- Executor (queries, mutations and subscriptions are supported).
-- Validation is work in progress.
-- Introspection isn't available yet.
-
-But the idea is to be a Haskell port of
-[`graphql-js`](https://github.com/graphql/graphql-js).
-
-For a more precise list of currently missing features see
-[issues](https://www.caraus.tech/projects/pub-graphql/issues).
-
-## Documentation
 
 API documentation is available through
 [Hackage](https://hackage.haskell.org/package/graphql).

graphql.cabal

@@ -1,13 +1,7 @@
 cabal-version: 2.2
 
--- This file has been generated from package.yaml by hpack version 0.33.0.
---
--- see: https://github.com/sol/hpack
---
--- hash: c89b0164372b6e02e4f338d3865dd6bb9dfd1a4475f25d808450480d73f94f91
-
 name:           graphql
-version:        0.11.0.0
+version:        1.0.1.0
 synopsis:       Haskell GraphQL implementation
 description:    Haskell <https://spec.graphql.org/June2018/ GraphQL> implementation.
 category:       Language
@@ -17,7 +11,7 @@ author:         Danny Navarro <j@dannynavarro.net>,
                 Matthías Páll Gissurarson <mpg@mpg.is>,
                 Sólrún Halla Einarsdóttir <she@mpg.is>
 maintainer:     belka@caraus.de
-copyright:      (c) 2019-2020 Eugen Wissner,
+copyright:      (c) 2019-2021 Eugen Wissner,
                 (c) 2015-2017 J. Daniel Navarro
 license:        MPL-2.0 AND BSD-3-Clause
 license-files:  LICENSE,
@@ -26,6 +20,9 @@ build-type:     Simple
 extra-source-files:
     CHANGELOG.md
     README.md
+tested-with:
+    GHC == 8.10.7
+  , GHC == 9.0.1
 
 source-repository head
   type: git
@@ -43,6 +40,8 @@ library
       Language.GraphQL.Error
       Language.GraphQL.Execute
       Language.GraphQL.Execute.Coerce
+      Language.GraphQL.Execute.OrderedMap
+      Language.GraphQL.TH
       Language.GraphQL.Type
       Language.GraphQL.Type.In
       Language.GraphQL.Type.Out
@@ -51,66 +50,61 @@ library
       Language.GraphQL.Validate.Validation
       Test.Hspec.GraphQL
   other-modules:
-      Language.GraphQL.Execute.Execution
-      Language.GraphQL.Execute.Subscribe
       Language.GraphQL.Execute.Transform
       Language.GraphQL.Type.Definition
       Language.GraphQL.Type.Internal
       Language.GraphQL.Validate.Rules
   hs-source-dirs:
       src
+  ghc-options: -Wall
   build-depends:
-      aeson
+      aeson >= 1.5.6 && < 1.6
-    , base >=4.7 && <5
+    , base >= 4.7 && < 5
-    , conduit
+    , conduit >= 1.3.4 && < 1.4
-    , containers
+    , containers >= 0.6.2 && < 0.7
-    , exceptions
+    , exceptions >= 0.10.4 && < 0.11
-    , hspec-expectations
+    , hspec-expectations >= 0.8.2 && < 0.9
-    , megaparsec
+    , megaparsec >= 9.0.1 && < 9.1
-    , parser-combinators
+    , parser-combinators >= 1.3.0 && < 1.4
-    , scientific
+    , scientific >= 0.3.7 && < 0.4
-    , text
+    , template-haskell >= 2.16 && < 2.18
-    , transformers
+    , text >= 1.2.4 && < 1.3
-    , unordered-containers
+    , transformers >= 0.5.6 && < 0.6
+    , unordered-containers >= 0.2.14 && < 0.3
+    , vector >= 0.12.3 && < 0.13
   default-language: Haskell2010
 
 test-suite graphql-test
   type: exitcode-stdio-1.0
   main-is: Spec.hs
   other-modules:
+      Language.GraphQL.AST.DocumentSpec
       Language.GraphQL.AST.EncoderSpec
       Language.GraphQL.AST.LexerSpec
       Language.GraphQL.AST.ParserSpec
       Language.GraphQL.ErrorSpec
       Language.GraphQL.Execute.CoerceSpec
+      Language.GraphQL.Execute.OrderedMapSpec
       Language.GraphQL.ExecuteSpec
       Language.GraphQL.Type.OutSpec
-      Language.GraphQL.ValidateSpec
+      Language.GraphQL.Validate.RulesSpec
       Test.DirectiveSpec
       Test.FragmentSpec
       Test.RootOperationSpec
-      Paths_graphql
-  autogen-modules:
-      Paths_graphql
   hs-source-dirs:
       tests
-  ghc-options: -threaded -rtsopts -with-rtsopts=-N
+  ghc-options: -threaded -rtsopts -with-rtsopts=-N -Wall
   build-depends:
-      QuickCheck
+      QuickCheck >= 2.14.1 && < 2.15
     , aeson
-    , base >=4.7 && <5
+    , base >= 4.8 && < 5
     , conduit
-    , containers
     , exceptions
     , graphql
-    , hspec
+    , hspec >= 2.8.2 && < 2.9
-    , hspec-expectations
+    , hspec-megaparsec >= 2.2.0 && < 2.3
-    , hspec-megaparsec
     , megaparsec
-    , parser-combinators
-    , raw-strings-qq
     , scientific
     , text
-    , transformers
     , unordered-containers
   default-language: Haskell2010

package.yaml

@@ -1,67 +0,0 @@
-name: graphql
-version: 0.11.0.0
-synopsis: Haskell GraphQL implementation
-description:
-  Haskell <https://spec.graphql.org/June2018/ GraphQL> implementation.
-maintainer: belka@caraus.de
-git: git://caraus.tech/pub/graphql.git
-homepage: https://www.caraus.tech/projects/pub-graphql
-bug-reports: https://www.caraus.tech/projects/pub-graphql/issues
-category: Language
-license: MPL-2.0 AND BSD-3-Clause
-
-copyright:
-- (c) 2019-2020 Eugen Wissner
-- (c) 2015-2017 J. Daniel Navarro
-author:
-- Danny Navarro <j@dannynavarro.net>
-- Matthías Páll Gissurarson <mpg@mpg.is>
-- Sólrún Halla Einarsdóttir <she@mpg.is>
-
-license-file:
-- LICENSE
-- LICENSE.MPL
-extra-source-files:
-- CHANGELOG.md
-- README.md
-
-dependencies:
-- aeson
-- base >= 4.7 && < 5
-- conduit
-- containers
-- exceptions
-- hspec-expectations
-- megaparsec
-- parser-combinators
-- scientific
-- text
-- transformers
-- unordered-containers
-
-library:
-  source-dirs: src
-  other-modules:
-  - Language.GraphQL.Execute.Execution
-  - Language.GraphQL.Execute.Subscribe
-  - Language.GraphQL.Execute.Transform
-  - Language.GraphQL.Type.Definition
-  - Language.GraphQL.Type.Internal
-  - Language.GraphQL.Validate.Rules
-
-tests:
-  graphql-test:
-    main: Spec.hs
-    source-dirs: tests
-    ghc-options:
-    - -threaded
-    - -rtsopts
-    - -with-rtsopts=-N
-    dependencies:
-    - graphql
-    - hspec
-    - hspec-megaparsec
-    - QuickCheck
-    - raw-strings-qq
-    generated-other-modules:
-    - Paths_graphql

src/Language/GraphQL/AST.hs

@@ -1,6 +1,4 @@
-{- This Source Code Form is subject to the terms of the Mozilla Public License,
+{-# LANGUAGE Safe #-}
-   v. 2.0. If a copy of the MPL was not distributed with this file, You can
-   obtain one at https://mozilla.org/MPL/2.0/. -}
 
 -- | Target AST for parser.
 module Language.GraphQL.AST

src/Language/GraphQL/AST/DirectiveLocation.hs

@@ -1,7 +1,3 @@
-{- This Source Code Form is subject to the terms of the Mozilla Public License,
-   v. 2.0. If a copy of the MPL was not distributed with this file, You can
-   obtain one at https://mozilla.org/MPL/2.0/. -}
-
 {-# LANGUAGE Safe #-}
 
 -- | Various parts of a GraphQL document can be annotated with directives. 

src/Language/GraphQL/AST/Document.hs

@@ -1,5 +1,6 @@
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE ExplicitForAll #-}
+{-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE Safe #-}
@@ -47,11 +48,15 @@ module Language.GraphQL.AST.Document
     , UnionMemberTypes(..)
     , Value(..)
     , VariableDefinition(..)
+    , escape
     ) where
 
+import Data.Char (ord)
 import Data.Foldable (toList)
 import Data.Int (Int32)
+import Data.List (intercalate)
 import Data.List.NonEmpty (NonEmpty)
+import Numeric (showFloat, showHex)
 import Data.Text (Text)
 import qualified Data.Text as Text
 import Language.GraphQL.AST.DirectiveLocation (DirectiveLocation)
@@ -79,7 +84,10 @@ instance Ord Location where
 data Node a = Node
     { node :: a
     , location :: Location
-    } deriving (Eq, Show)
+    } deriving Eq
+
+instance Show a => Show (Node a) where
+    show Node{ node } = show node
 
 instance Functor Node where
     fmap f Node{..} = Node (f node) location
@@ -218,6 +226,34 @@ type TypeCondition = Name
 
 -- ** Input Values
 
+-- | Escapes a single character according to the GraphQL escaping rules for
+-- double-quoted string values.
+--
+-- Characters, that should be escaped, are written as escaped characters with a
+-- backslash or Unicode with an \"\\u\". Other characters are returned as
+-- strings.
+escape :: Char -> String
+escape char'
+    | char' == '\\' = "\\\\"
+    | char' == '\"' = "\\\""
+    | char' == '\b' = "\\b"
+    | char' == '\f' = "\\f"
+    | char' == '\n' = "\\n"
+    | char' == '\r' = "\\r"
+    | char' == '\t' = "\\t"
+    | char' < '\x0010' = unicode  "\\u000" char'
+    | char' < '\x0020' = unicode "\\u00" char'
+    | otherwise = [char']
+  where
+    unicode prefix uchar = prefix <> (showHex $ ord uchar) ""
+
+showList' :: Show a => [a] -> String
+showList' list = "[" ++ intercalate ", " (show <$> list) ++ "]"
+
+showObject :: Show a => [ObjectField a] -> String
+showObject fields =
+    "{ " ++ intercalate ", " (show <$> fields) ++ " }"
+
 -- | Input value (literal or variable).
 data Value
     = Variable Name
@@ -227,9 +263,21 @@ data Value
     | Boolean Bool
     | Null
     | Enum Name
-    | List [Value]
+    | List [Node Value]
     | Object [ObjectField Value]
-    deriving (Eq, Show)
+    deriving Eq
+
+instance Show Value where
+    showList = mappend . showList'
+    show (Variable variableName) = '$' : Text.unpack variableName
+    show (Int integer) = show integer
+    show (Float float) = show $ ConstFloat float
+    show (String text) = show $  ConstString text
+    show (Boolean boolean) = show boolean
+    show Null = "null"
+    show (Enum name) = Text.unpack name
+    show (List list) = show list
+    show (Object fields) = showObject fields
 
 -- | Constant input value.
 data ConstValue
@@ -239,9 +287,20 @@ data ConstValue
     | ConstBoolean Bool
     | ConstNull
     | ConstEnum Name
-    | ConstList [ConstValue]
+    | ConstList [Node ConstValue]
     | ConstObject [ObjectField ConstValue]
-    deriving (Eq, Show)
+    deriving Eq
+
+instance Show ConstValue where
+    showList = mappend . showList'
+    show (ConstInt integer) = show integer
+    show (ConstFloat float) = showFloat float mempty
+    show (ConstString text) = "\"" <> Text.foldr (mappend . escape) "\"" text
+    show (ConstBoolean boolean) = show boolean
+    show ConstNull = "null"
+    show (ConstEnum name) = Text.unpack name
+    show (ConstList list) = show list
+    show (ConstObject fields) = showObject fields
 
 -- | Key-value pair.
 --
@@ -250,7 +309,13 @@ data ObjectField a = ObjectField
     { name :: Name
     , value :: Node a
     , location :: Location
-    } deriving (Eq, Show)
+    } deriving Eq
+
+instance Show a => Show (ObjectField a) where
+    show ObjectField{..} = Text.unpack name ++ ": " ++ show value
+
+instance Functor ObjectField where
+    fmap f ObjectField{..} = ObjectField name (f <$> value) location
 
 -- ** Variables
 
@@ -259,13 +324,13 @@ data ObjectField a = ObjectField
 -- Each operation can include a list of variables:
 --
 -- @
--- query (protagonist: String = "Zarathustra") {
+-- query (protagonist: String = \"Zarathustra\") {
 --   getAuthor(protagonist: $protagonist)
 -- }
 -- @
 --
 -- This query defines an optional variable @protagonist@ of type @String@,
--- its default value is "Zarathustra". If no default value is defined and no
+-- its default value is \"Zarathustra\". If no default value is defined and no
 -- value is provided, a variable can still be @null@ if its type is nullable.
 --
 -- Variables are usually passed along with the query, but not in the query
@@ -281,7 +346,12 @@ data Type
     = TypeNamed Name
     | TypeList Type
     | TypeNonNull NonNullType
-    deriving (Eq, Show)
+    deriving Eq
+
+instance Show Type where
+    show (TypeNamed typeName) = Text.unpack typeName
+    show (TypeList listType) = concat ["[", show listType, "]"]
+    show (TypeNonNull nonNullType) = show nonNullType
 
 -- | Represents type names.
 type NamedType = Name
@@ -290,7 +360,11 @@ type NamedType = Name
 data NonNullType
     = NonNullTypeNamed Name
     | NonNullTypeList Type
-    deriving (Eq, Show)
+    deriving Eq
+
+instance Show NonNullType where
+    show (NonNullTypeNamed typeName) = '!' : Text.unpack typeName
+    show (NonNullTypeList listType) =  concat ["![", show listType, "]"]
 
 -- ** Directives
 

src/Language/GraphQL/AST/Encoder.hs

@@ -16,7 +16,6 @@ module Language.GraphQL.AST.Encoder
     , value
     ) where
 
-import Data.Char (ord)
 import Data.Foldable (fold)
 import qualified Data.List.NonEmpty as NonEmpty
 import Data.Text (Text)
@@ -25,7 +24,7 @@ import qualified Data.Text.Lazy as Lazy (Text)
 import qualified Data.Text.Lazy as Lazy.Text
 import Data.Text.Lazy.Builder (Builder)
 import qualified Data.Text.Lazy.Builder as Builder
-import Data.Text.Lazy.Builder.Int (decimal, hexadecimal)
+import Data.Text.Lazy.Builder.Int (decimal)
 import Data.Text.Lazy.Builder.RealFloat (realFloat)
 import qualified Language.GraphQL.AST.Document as Full
 
@@ -220,7 +219,7 @@ fromConstValue (Full.ConstBoolean  x) = Full.Boolean x
 fromConstValue Full.ConstNull = Full.Null
 fromConstValue (Full.ConstString string) = Full.String string
 fromConstValue (Full.ConstEnum x) = Full.Enum x
-fromConstValue (Full.ConstList x) = Full.List $ fromConstValue <$> x
+fromConstValue (Full.ConstList x) = Full.List $ fmap fromConstValue <$> x
 fromConstValue (Full.ConstObject x) = Full.Object $ fromConstObjectField <$> x
   where
     fromConstObjectField Full.ObjectField{value = value', ..} =
@@ -234,11 +233,12 @@ quote :: Builder.Builder
 quote = Builder.singleton '\"'
 
 oneLine :: Text -> Builder
-oneLine string = quote <> Text.foldr (mappend . escape) quote string
+oneLine string = quote <> Text.foldr merge quote string
+  where
+    merge = mappend . Builder.fromString . Full.escape
 
 stringValue :: Formatter -> Text -> Lazy.Text
-stringValue Minified string = Builder.toLazyText
+stringValue Minified string = Builder.toLazyText $ oneLine string
-    $ quote <> Text.foldr (mappend . escape) quote string
 stringValue (Pretty indentation) string =
   if hasEscaped string
   then stringValue Minified string
@@ -266,23 +266,8 @@ stringValue (Pretty indentation) string =
             = Builder.fromLazyText (indent (indentation + 1))
             <> line' <> newline <> acc
 
-escape :: Char -> Builder
+listValue :: Formatter -> [Full.Node Full.Value] -> Lazy.Text
-escape char'
+listValue formatter = bracketsCommas formatter $ value formatter . Full.node
-    | char' == '\\' = Builder.fromString "\\\\"
-    | char' == '\"' = Builder.fromString "\\\""
-    | char' == '\b' = Builder.fromString "\\b"
-    | char' == '\f' = Builder.fromString "\\f"
-    | char' == '\n' = Builder.fromString "\\n"
-    | char' == '\r' = Builder.fromString "\\r"
-    | char' == '\t' = Builder.fromString "\\t"
-    | char' < '\x0010' = unicode  "\\u000" char'
-    | char' < '\x0020' = unicode "\\u00" char'
-    | otherwise = Builder.singleton char'
-  where
-    unicode prefix = mappend (Builder.fromString prefix) . (hexadecimal . ord)
-
-listValue :: Formatter -> [Full.Value] -> Lazy.Text
-listValue formatter = bracketsCommas formatter $ value formatter
 
 objectValue :: Formatter -> [Full.ObjectField Full.Value] -> Lazy.Text
 objectValue formatter = intercalate $ objectField formatter

src/Language/GraphQL/AST/Parser.hs

@@ -14,11 +14,7 @@ import qualified Control.Applicative.Combinators.NonEmpty as NonEmpty
 import Data.List.NonEmpty (NonEmpty(..))
 import Data.Text (Text)
 import qualified Language.GraphQL.AST.DirectiveLocation as Directive
-import Language.GraphQL.AST.DirectiveLocation
+import Language.GraphQL.AST.DirectiveLocation (DirectiveLocation)
-    ( DirectiveLocation
-    , ExecutableDirectiveLocation
-    , TypeSystemDirectiveLocation
-    )
 import qualified Language.GraphQL.AST.Document as Full
 import Language.GraphQL.AST.Lexer
 import Text.Megaparsec
@@ -96,34 +92,28 @@ directiveLocations = optional pipe
     <?> "DirectiveLocations"
 
 directiveLocation :: Parser DirectiveLocation
-directiveLocation
+directiveLocation = e (Directive.Query <$ symbol "QUERY")
-    = Directive.ExecutableDirectiveLocation <$> executableDirectiveLocation
+    <|> e (Directive.Mutation <$ symbol "MUTATION")
-    <|> Directive.TypeSystemDirectiveLocation <$> typeSystemDirectiveLocation
+    <|> e (Directive.Subscription <$ symbol "SUBSCRIPTION")
+    <|> t (Directive.FieldDefinition <$ symbol "FIELD_DEFINITION")
+    <|> e (Directive.Field <$ symbol "FIELD")
+    <|> e (Directive.FragmentDefinition <$ "FRAGMENT_DEFINITION")
+    <|> e (Directive.FragmentSpread <$ "FRAGMENT_SPREAD")
+    <|> e (Directive.InlineFragment <$ "INLINE_FRAGMENT")
+    <|> t (Directive.Schema <$ symbol "SCHEMA")
+    <|> t (Directive.Scalar <$ symbol "SCALAR")
+    <|> t (Directive.Object <$ symbol "OBJECT")
+    <|> t (Directive.ArgumentDefinition <$ symbol "ARGUMENT_DEFINITION")
+    <|> t (Directive.Interface <$ symbol "INTERFACE")
+    <|> t (Directive.Union <$ symbol "UNION")
+    <|> t (Directive.EnumValue <$ symbol "ENUM_VALUE")
+    <|> t (Directive.Enum <$ symbol "ENUM")
+    <|> t (Directive.InputObject <$ symbol "INPUT_OBJECT")
+    <|> t (Directive.InputFieldDefinition <$ symbol "INPUT_FIELD_DEFINITION")
     <?> "DirectiveLocation"
-
+  where
-executableDirectiveLocation :: Parser ExecutableDirectiveLocation
+    e = fmap Directive.ExecutableDirectiveLocation
-executableDirectiveLocation = Directive.Query <$ symbol "QUERY"
+    t = fmap Directive.TypeSystemDirectiveLocation
-    <|> Directive.Mutation <$ symbol "MUTATION"
-    <|> Directive.Subscription <$ symbol "SUBSCRIPTION"
-    <|> Directive.Field <$ symbol "FIELD"
-    <|> Directive.FragmentDefinition <$ "FRAGMENT_DEFINITION"
-    <|> Directive.FragmentSpread <$ "FRAGMENT_SPREAD"
-    <|> Directive.InlineFragment <$ "INLINE_FRAGMENT"
-    <?> "ExecutableDirectiveLocation"
-
-typeSystemDirectiveLocation :: Parser TypeSystemDirectiveLocation
-typeSystemDirectiveLocation = Directive.Schema <$ symbol "SCHEMA"
-    <|> Directive.Scalar <$ symbol "SCALAR"
-    <|> Directive.Object <$ symbol "OBJECT"
-    <|> Directive.FieldDefinition <$ symbol "FIELD_DEFINITION"
-    <|> Directive.ArgumentDefinition <$ symbol "ARGUMENT_DEFINITION"
-    <|> Directive.Interface <$ symbol "INTERFACE"
-    <|> Directive.Union <$ symbol "UNION"
-    <|> Directive.Enum <$ symbol "ENUM"
-    <|> Directive.EnumValue <$ symbol "ENUM_VALUE"
-    <|> Directive.InputObject <$ symbol "INPUT_OBJECT"
-    <|> Directive.InputFieldDefinition <$ symbol "INPUT_FIELD_DEFINITION"
-    <?> "TypeSystemDirectiveLocation"
 
 typeDefinition :: Full.Description -> Parser Full.TypeDefinition
 typeDefinition description' = scalarTypeDefinition description'
@@ -460,7 +450,7 @@ value = Full.Variable <$> variable
     <|> Full.Null <$  nullValue
     <|> Full.String <$> stringValue
     <|> Full.Enum <$> try enumValue
-    <|> Full.List <$> brackets (some value)
+    <|> Full.List <$> brackets (some $ valueNode value)
     <|> Full.Object <$> braces (some $ objectField $ valueNode value)
     <?> "Value"
 
@@ -471,8 +461,8 @@ constValue = Full.ConstFloat <$> try float
     <|> Full.ConstNull <$ nullValue
     <|> Full.ConstString <$> stringValue
     <|> Full.ConstEnum <$> try enumValue
-    <|> Full.ConstList <$> brackets (some constValue)
+    <|> Full.ConstList <$> brackets (many $ valueNode constValue)
-    <|> Full.ConstObject <$> braces (some $ objectField $ valueNode constValue)
+    <|> Full.ConstObject <$> braces (many $ objectField $ valueNode constValue)
     <?> "Value"
 
 booleanValue :: Parser Bool

src/Language/GraphQL/Error.hs

@@ -1,6 +1,9 @@
+{- This Source Code Form is subject to the terms of the Mozilla Public License,
+   v. 2.0. If a copy of the MPL was not distributed with this file, You can
+   obtain one at https://mozilla.org/MPL/2.0/. -}
+
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE ExistentialQuantification #-}
-{-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
 
 -- | Error handling.
@@ -41,12 +44,6 @@ import Text.Megaparsec
     , unPos
     )
 
--- | Executor context.
-data Resolution m = Resolution
-    { errors :: Seq Error
-    , types :: HashMap Name (Schema.Type m)
-    }
-
 -- | Wraps a parse error into a list of errors.
 parseError :: (Applicative f, Serialize a)
     => ParseErrorBundle Text Void
@@ -66,28 +63,6 @@ parseError ParseErrorBundle{..}  =
             sourcePosition = pstateSourcePos newState
          in (result |> errorObject x sourcePosition, newState)
 
--- | A wrapper to pass error messages around.
-type CollectErrsT m = StateT (Resolution m) m
-
--- | Adds an error to the list of errors.
-addErr :: Monad m => Error -> CollectErrsT m ()
-addErr v = modify appender
-  where
-    appender :: Monad m => Resolution m -> Resolution m
-    appender resolution@Resolution{..} = resolution{ errors = errors |> v }
-
-makeErrorMessage :: Text -> Error
-makeErrorMessage s = Error s [] []
-
--- | Constructs a response object containing only the error with the given
--- message.
-singleError :: Serialize a => Text -> Response a
-singleError message = Response null $ Seq.singleton $ makeErrorMessage message
-
--- | Convenience function for just wrapping an error message.
-addErrMsg :: (Monad m, Serialize a) => Text -> CollectErrsT m a
-addErrMsg errorMessage = (addErr . makeErrorMessage) errorMessage >> pure null
-
 -- | If an error can be associated to a particular field in the GraphQL result,
 -- it must contain an entry with the key path that details the path of the
 -- response field which experienced the error. This allows clients to identify
@@ -126,8 +101,13 @@ instance Show ResolverException where
 
 instance Exception ResolverException
 
+-- * Deprecated
+
 -- | Runs the given query computation, but collects the errors into an error
 -- list, which is then sent back with the data.
+--
+-- /runCollectErrs was part of the old executor and isn't used anymore, it will
+-- be deprecated in the future and removed./
 runCollectErrs :: (Monad m, Serialize a)
     => HashMap Name (Schema.Type m)
     -> CollectErrsT m a
@@ -136,3 +116,41 @@ runCollectErrs types' res = do
     (dat, Resolution{..}) <- runStateT res
         $ Resolution{ errors = Seq.empty, types = types' }
     pure $ Response dat errors
+
+-- | Executor context.
+--
+-- /Resolution was part of the old executor and isn't used anymore, it will be
+-- deprecated in the future and removed./
+data Resolution m = Resolution
+    { errors :: Seq Error
+    , types :: HashMap Name (Schema.Type m)
+    }
+
+-- | A wrapper to pass error messages around.
+--
+-- /CollectErrsT was part of the old executor and isn't used anymore, it will be
+-- deprecated in the future and removed./
+type CollectErrsT m = StateT (Resolution m) m
+
+-- | Adds an error to the list of errors.
+{-# DEPRECATED #-}
+addErr :: Monad m => Error -> CollectErrsT m ()
+addErr v = modify appender
+  where
+    appender :: Monad m => Resolution m -> Resolution m
+    appender resolution@Resolution{..} = resolution{ errors = errors |> v }
+
+{-# DEPRECATED #-}
+makeErrorMessage :: Text -> Error
+makeErrorMessage s = Error s [] []
+
+-- | Constructs a response object containing only the error with the given
+-- message.
+{-# DEPRECATED #-}
+singleError :: Serialize a => Text -> Response a
+singleError message = Response null $ Seq.singleton $ Error message [] []
+
+-- | Convenience function for just wrapping an error message.
+{-# DEPRECATED #-}
+addErrMsg :: (Monad m, Serialize a) => Text -> CollectErrsT m a
+addErrMsg errorMessage = (addErr . makeErrorMessage) errorMessage >> pure null

src/Language/GraphQL/Execute.hs

@@ -1,4 +1,13 @@
+{- This Source Code Form is subject to the terms of the Mozilla Public License,
+   v. 2.0. If a copy of the MPL was not distributed with this file, You can
+   obtain one at https://mozilla.org/MPL/2.0/. -}
+
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE ExistentialQuantification #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE ViewPatterns #-}
+{-# LANGUAGE TypeApplications #-}
 
 -- | This module provides functions to execute a @GraphQL@ request.
 module Language.GraphQL.Execute
@@ -6,19 +15,209 @@ module Language.GraphQL.Execute
     , module Language.GraphQL.Execute.Coerce
     ) where
 
-import Control.Monad.Catch (MonadCatch)
+import Conduit (mapMC, (.|))
+import Control.Arrow (left)
+import Control.Monad.Catch
+     ( Exception(..)
+     , Handler(..)
+     , MonadCatch(..)
+     , MonadThrow(..)
+     , SomeException(..)
+     , catches
+     )
+import Control.Monad.Trans.Class (MonadTrans(..))
+import Control.Monad.Trans.Reader (ReaderT(..), ask, runReaderT)
+import Control.Monad.Trans.Writer (WriterT(..), runWriterT)
+import qualified Control.Monad.Trans.Writer as Writer
+import Control.Monad (foldM)
+import qualified Language.GraphQL.AST.Document as Full
+import Data.Foldable (find)
 import Data.HashMap.Strict (HashMap)
-import Data.Sequence (Seq(..))
+import qualified Data.HashMap.Strict as HashMap
+import Data.List.NonEmpty (NonEmpty(..))
+import qualified Data.List.NonEmpty as NonEmpty
+import Data.Maybe (fromMaybe)
+import Data.Sequence (Seq)
+import qualified Data.Sequence as Seq
 import Data.Text (Text)
-import Language.GraphQL.AST.Document (Document, Name)
+import qualified Data.Text as Text
+import Data.Typeable (cast)
+import GHC.Records (HasField(..))
 import Language.GraphQL.Execute.Coerce
-import Language.GraphQL.Execute.Execution
+import Language.GraphQL.Execute.OrderedMap (OrderedMap)
+import qualified Language.GraphQL.Execute.OrderedMap as OrderedMap
 import qualified Language.GraphQL.Execute.Transform as Transform
-import qualified Language.GraphQL.Execute.Subscribe as Subscribe
+import qualified Language.GraphQL.Type.In as In
-import Language.GraphQL.Error
-import qualified Language.GraphQL.Type.Definition as Definition
 import qualified Language.GraphQL.Type.Out as Out
-import Language.GraphQL.Type.Schema
+import qualified Language.GraphQL.Type as Type
+import qualified Language.GraphQL.Type.Internal as Type.Internal
+import Language.GraphQL.Type.Schema (Schema, Type)
+import qualified Language.GraphQL.Type.Schema as Schema
+import Language.GraphQL.Error
+    ( Error(..)
+    , Response(..)
+    , Path(..)
+    , ResolverException(..)
+    , ResponseEventStream
+    )
+import Prelude hiding (null)
+
+newtype ExecutorT m a = ExecutorT
+    { runExecutorT :: ReaderT (HashMap Full.Name (Type m)) (WriterT (Seq Error) m) a
+    }
+
+instance Functor m => Functor (ExecutorT m) where
+    fmap f = ExecutorT . fmap f . runExecutorT
+
+instance Applicative m => Applicative (ExecutorT m) where
+    pure = ExecutorT . pure
+    ExecutorT f <*> ExecutorT x = ExecutorT $ f <*> x
+
+instance Monad m => Monad (ExecutorT m) where
+    ExecutorT x >>= f = ExecutorT $ x >>= runExecutorT . f
+
+instance MonadTrans ExecutorT where
+    lift = ExecutorT . lift . lift
+
+instance MonadThrow m => MonadThrow (ExecutorT m) where
+    throwM = lift . throwM
+
+instance MonadCatch m => MonadCatch (ExecutorT m) where
+  catch (ExecutorT stack) handler =
+      ExecutorT $ catch stack $ runExecutorT . handler
+
+data GraphQLException = forall e. Exception e => GraphQLException e
+
+instance Show GraphQLException where
+    show (GraphQLException e) = show e
+
+instance Exception GraphQLException
+
+graphQLExceptionToException :: Exception e => e -> SomeException
+graphQLExceptionToException = toException . GraphQLException
+
+graphQLExceptionFromException :: Exception e => SomeException -> Maybe e
+graphQLExceptionFromException e = do
+    GraphQLException graphqlException <- fromException e
+    cast graphqlException
+
+data ResultException = forall e. Exception e => ResultException e
+
+instance Show ResultException where
+    show (ResultException e) = show e
+
+instance Exception ResultException where
+    toException = graphQLExceptionToException
+    fromException = graphQLExceptionFromException
+
+resultExceptionToException :: Exception e => e -> SomeException
+resultExceptionToException = toException . ResultException
+
+resultExceptionFromException :: Exception e => SomeException -> Maybe e
+resultExceptionFromException e = do
+    ResultException resultException <- fromException e
+    cast resultException
+
+data FieldException = forall e. Exception e => FieldException Full.Location [Path] e
+
+instance Show FieldException where
+    show (FieldException _ _ e) = displayException e
+
+instance Exception FieldException where
+    toException = graphQLExceptionToException
+    fromException = graphQLExceptionFromException
+
+data ValueCompletionException = ValueCompletionException String Type.Value
+
+instance Show ValueCompletionException where
+    show (ValueCompletionException typeRepresentation found) = concat
+        [ "Value completion error. Expected type "
+        , typeRepresentation
+        , ", found: "
+        , show found
+        , "."
+        ]
+
+instance Exception ValueCompletionException where
+    toException = resultExceptionToException
+    fromException = resultExceptionFromException
+
+data InputCoercionException =
+    InputCoercionException String In.Type (Maybe (Full.Node Transform.Input))
+
+instance Show InputCoercionException where
+    show (InputCoercionException argumentName argumentType Nothing) = concat
+        [ "Required argument \""
+        , argumentName
+        , "\" of type "
+        , show argumentType
+        , " not specified."
+        ]
+    show (InputCoercionException argumentName argumentType (Just givenValue)) = concat
+        [ "Argument \""
+        , argumentName
+        , "\" has invalid type. Expected type "
+        , show argumentType
+        , ", found: "
+        , show givenValue
+        , "."
+        ]
+
+instance Exception InputCoercionException where
+    toException = graphQLExceptionToException
+    fromException = graphQLExceptionFromException
+
+newtype ResultCoercionException = ResultCoercionException String
+
+instance Show ResultCoercionException where
+    show (ResultCoercionException typeRepresentation) = concat
+        [ "Unable to coerce result to "
+        , typeRepresentation
+        , "."
+        ]
+
+instance Exception ResultCoercionException where
+    toException = resultExceptionToException
+    fromException = resultExceptionFromException
+
+-- | Query error types.
+data QueryError
+    = OperationNameRequired
+    | OperationNotFound String
+    | CoercionError Full.VariableDefinition
+    | UnknownInputType Full.VariableDefinition
+
+tell :: Monad m => Seq Error -> ExecutorT m ()
+tell = ExecutorT . lift . Writer.tell
+
+queryError :: QueryError -> Error
+queryError OperationNameRequired =
+    Error{ message = "Operation name is required.", locations = [], path = [] }
+queryError (OperationNotFound operationName) =
+    let queryErrorMessage = Text.concat
+            [ "Operation \""
+            , Text.pack operationName
+            , "\" not found."
+            ]
+     in Error{ message = queryErrorMessage, locations = [], path = [] }
+queryError (CoercionError variableDefinition) =
+    let Full.VariableDefinition variableName _ _ location = variableDefinition
+        queryErrorMessage = Text.concat
+            [ "Failed to coerce the variable \""
+            , variableName
+            , "\"."
+            ]
+     in Error{ message = queryErrorMessage, locations = [location], path = [] }
+queryError (UnknownInputType variableDefinition) =
+    let Full.VariableDefinition variableName variableTypeName _ location = variableDefinition
+        queryErrorMessage = Text.concat
+            [ "Variable \""
+            , variableName
+            , "\" has unknown type \""
+            , Text.pack $ show variableTypeName
+            , "\"."
+            ]
+     in Error{ message = queryErrorMessage, locations = [location], path = [] }
 
 -- | The substitution is applied to the document, and the resolvers are applied
 -- to the resulting fields. The operation name can be used if the document
@@ -29,35 +228,495 @@ import Language.GraphQL.Type.Schema
 execute :: (MonadCatch m, VariableValue a, Serialize b)
     => Schema m -- ^ Resolvers.
     -> Maybe Text -- ^ Operation name.
-    -> HashMap Name a -- ^ Variable substitution function.
+    -> HashMap Full.Name a -- ^ Variable substitution function.
-    -> Document -- @GraphQL@ document.
+    -> Full.Document -- @GraphQL@ document.
     -> m (Either (ResponseEventStream m b) (Response b))
-execute schema' operationName subs document =
+execute schema' operationName subs document' =
-    case Transform.document schema' operationName subs document of
+    executeRequest schema' document' (Text.unpack <$> operationName) subs
-        Left queryError -> pure
-            $ Right
-            $ singleError
-            $ Transform.queryError queryError
-        Right transformed -> executeRequest transformed
 
-executeRequest :: (MonadCatch m, Serialize a)
+executeRequest :: (MonadCatch m, Serialize a, VariableValue b)
-    => Transform.Document m
+    => Schema m
+    -> Full.Document
+    -> Maybe String
+    -> HashMap Full.Name b
     -> m (Either (ResponseEventStream m a) (Response a))
-executeRequest (Transform.Document types' rootObjectType operation)
+executeRequest schema sourceDocument operationName variableValues = do
-    | (Transform.Query _ fields) <- operation =
+    operationAndVariables <- sequence buildOperation
-        Right <$> executeOperation types' rootObjectType fields
+    case operationAndVariables of
-    | (Transform.Mutation _ fields) <- operation =
+        Left queryError' -> pure
-        Right <$> executeOperation types' rootObjectType fields
+            $ Right
-    | (Transform.Subscription _ fields) <- operation
+            $ Response null $ pure $ queryError queryError'
-        = either (Right . singleError) Left
+        Right operation
-        <$> Subscribe.subscribe types' rootObjectType fields
+            | Transform.Operation Full.Query topSelections _operationLocation <- operation ->
+                 Right <$> executeQuery topSelections schema
+            | Transform.Operation Full.Mutation topSelections operationLocation <- operation ->
+                Right <$> executeMutation topSelections schema operationLocation
+            | Transform.Operation Full.Subscription topSelections operationLocation <- operation ->
+                either rightErrorResponse Left <$> subscribe topSelections schema operationLocation
+  where
+    schemaTypes = Schema.types schema
+    (operationDefinitions, fragmentDefinitions') =
+        Transform.document sourceDocument
+    buildOperation = do
+        operationDefinition <- getOperation operationDefinitions operationName
+        coercedVariableValues <- coerceVariableValues
+            schemaTypes
+            operationDefinition
+            variableValues
+        let replacement = Transform.Replacement
+                { variableValues = coercedVariableValues
+                , fragmentDefinitions = fragmentDefinitions'
+                , visitedFragments = mempty
+                , types = schemaTypes
+                }
+        pure $ flip runReaderT replacement
+            $ Transform.runTransformT
+            $ Transform.transform operationDefinition
 
--- This is actually executeMutation, but we don't distinguish between queries
+rightErrorResponse :: Serialize b => forall a. Error -> Either a (Response b)
--- and mutations yet.
+rightErrorResponse = Right . Response null . pure
-executeOperation :: (MonadCatch m, Serialize a)
+
-    => HashMap Name (Type m)
+getOperation :: [Full.OperationDefinition] -> Maybe String -> Either QueryError Full.OperationDefinition
+getOperation [operation] Nothing = Right operation
+getOperation operations (Just givenOperationName)
+    = maybe (Left $ OperationNotFound givenOperationName) Right
+    $ find findOperationByName operations
+  where
+    findOperationByName (Full.OperationDefinition _ (Just operationName) _ _ _ _) =
+        givenOperationName == Text.unpack operationName
+    findOperationByName _ = False
+getOperation _ _ = Left OperationNameRequired
+
+executeQuery :: (MonadCatch m, Serialize a)
+    => Seq (Transform.Selection m)
+    -> Schema m
+    -> m (Response a)
+executeQuery topSelections schema = do
+    let queryType = Schema.query schema
+    (data', errors) <- runWriterT
+        $ flip runReaderT (Schema.types schema)
+        $ runExecutorT
+        $ catch (executeSelectionSet topSelections queryType Type.Null [])
+        handleException
+    pure $ Response data' errors
+
+handleException :: (MonadCatch m, Serialize a)
+    => FieldException
+    -> ExecutorT m a
+handleException (FieldException fieldLocation errorPath next) =
+    let newError = constructError next fieldLocation errorPath
+     in tell (Seq.singleton newError) >> pure null
+
+constructError :: Exception e => e -> Full.Location -> [Path] -> Error
+constructError e fieldLocation errorPath = Error
+    { message = Text.pack (displayException e)
+    , path = reverse errorPath
+    , locations = [fieldLocation]
+    }
+
+executeMutation :: (MonadCatch m, Serialize a)
+    => Seq (Transform.Selection m)
+    -> Schema m
+    -> Full.Location
+    -> m (Response a)
+executeMutation topSelections schema operationLocation
+    | Just mutationType <- Schema.mutation schema = do
+        (data', errors) <- runWriterT
+            $ flip runReaderT (Schema.types schema)
+            $ runExecutorT
+            $ catch (executeSelectionSet topSelections mutationType Type.Null [])
+            handleException
+        pure $ Response data' errors
+    | otherwise = pure
+        $ Response null
+        $ Seq.singleton
+        $ Error "Schema doesn't support mutations." [operationLocation] []
+
+executeSelectionSet :: (MonadCatch m, Serialize a)
+    => Seq (Transform.Selection m)
+    -> Out.ObjectType m
+    -> Type.Value
+    -> [Path]
+    -> ExecutorT m a
+executeSelectionSet selections objectType objectValue errorPath = do
+    let groupedFieldSet = collectFields objectType selections
+    resolvedValues <- OrderedMap.traverseMaybe go groupedFieldSet
+    coerceResult (Out.NonNullObjectType objectType) $ Object resolvedValues
+  where
+    executeField' fields resolver =
+        executeField objectValue fields resolver errorPath
+    Out.ObjectType _ _ _ resolvers = objectType
+    go fields@(Transform.Field _ fieldName _ _ _ :| _) =
+        traverse (executeField' fields) $ HashMap.lookup fieldName resolvers
+
+fieldsSegment :: forall m. NonEmpty (Transform.Field m) -> Path
+fieldsSegment (Transform.Field alias fieldName _ _ _ :| _) =
+    Segment (fromMaybe fieldName alias)
+
+viewResolver :: Out.Resolver m -> (Out.Field m, Out.Resolve m)
+viewResolver (Out.ValueResolver resolverField' resolveFunction) =
+    (resolverField', resolveFunction)
+viewResolver (Out.EventStreamResolver resolverField' resolveFunction _) =
+    (resolverField', resolveFunction)
+
+executeField :: forall m a
+    . (MonadCatch m, Serialize a)
+    => Type.Value
+    -> NonEmpty (Transform.Field m)
+    -> Out.Resolver m
+    -> [Path]
+    -> ExecutorT m a
+executeField objectValue fields (viewResolver -> resolverPair) errorPath =
+    let Transform.Field _ fieldName inputArguments _ fieldLocation :| _ = fields
+     in catches (go fieldName inputArguments)
+        [ Handler nullResultHandler
+        , Handler (inputCoercionHandler fieldLocation)
+        , Handler (resultHandler fieldLocation)
+        , Handler (resolverHandler fieldLocation)
+        ]
+  where
+    inputCoercionHandler :: (MonadCatch m, Serialize a)
+        => Full.Location
+        -> InputCoercionException
+        -> ExecutorT m a
+    inputCoercionHandler _ e@(InputCoercionException _ _ (Just valueNode)) =
+        let argumentLocation = getField @"location" valueNode
+         in exceptionHandler argumentLocation e
+    inputCoercionHandler fieldLocation e = exceptionHandler fieldLocation e
+    resultHandler :: (MonadCatch m, Serialize a)
+        => Full.Location
+        -> ResultException
+        -> ExecutorT m a
+    resultHandler = exceptionHandler
+    resolverHandler :: (MonadCatch m, Serialize a)
+        => Full.Location
+        -> ResolverException
+        -> ExecutorT m a
+    resolverHandler = exceptionHandler
+    nullResultHandler :: (MonadCatch m, Serialize a)
+        => FieldException
+        -> ExecutorT m a
+    nullResultHandler e@(FieldException fieldLocation errorPath' next) =
+        let newError = constructError next fieldLocation errorPath'
+         in if Out.isNonNullType fieldType
+             then throwM e
+             else returnError newError
+    exceptionHandler errorLocation e =
+        let newPath = fieldsSegment fields : errorPath
+            newError = constructError e errorLocation newPath
+         in if Out.isNonNullType fieldType
+             then throwM $ FieldException errorLocation newPath e
+             else returnError newError
+    returnError newError = tell (Seq.singleton newError) >> pure null
+    go fieldName inputArguments = do
+        argumentValues <- coerceArgumentValues argumentTypes inputArguments
+        resolvedValue <-
+           resolveFieldValue resolveFunction objectValue fieldName argumentValues
+        completeValue fieldType fields errorPath resolvedValue
+    (resolverField, resolveFunction) = resolverPair
+    Out.Field _ fieldType argumentTypes = resolverField
+
+resolveFieldValue :: MonadCatch m
+    => Out.Resolve m
+    -> Type.Value
+    -> Full.Name
+    -> Type.Subs
+    -> ExecutorT m Type.Value
+resolveFieldValue resolver objectValue _fieldName argumentValues =
+    lift $ runReaderT resolver context
+  where
+    context = Type.Context
+        { Type.arguments = Type.Arguments argumentValues
+        , Type.values = objectValue
+        }
+
+resolveAbstractType :: Monad m
+    => Type.Internal.AbstractType m
+    -> Type.Subs
+    -> ExecutorT m (Maybe (Out.ObjectType m))
+resolveAbstractType abstractType values'
+    | Just (Type.String typeName) <- HashMap.lookup "__typename" values' = do
+        types' <- ExecutorT ask
+        case HashMap.lookup typeName types' of
+            Just (Type.Internal.ObjectType objectType) ->
+                if Type.Internal.instanceOf objectType abstractType
+                    then pure $ Just objectType
+                    else pure Nothing
+            _ -> pure Nothing
+    | otherwise = pure Nothing
+
+completeValue :: (MonadCatch m, Serialize a)
+    => Out.Type m
+    -> NonEmpty (Transform.Field m)
+    -> [Path]
+    -> Type.Value
+    -> ExecutorT m a
+completeValue (Out.isNonNullType -> False) _ _ Type.Null =
+    pure null
+completeValue outputType@(Out.ListBaseType listType) fields errorPath (Type.List list)
+    = foldM go (0, []) list >>= coerceResult outputType . List . snd
+  where
+    go (index, accumulator) listItem = do
+        let updatedPath = Index index : errorPath
+        completedValue <- completeValue listType fields updatedPath listItem
+        pure (index + 1, completedValue : accumulator)
+completeValue outputType@(Out.ScalarBaseType _) _ _ (Type.Int int) =
+    coerceResult outputType $ Int int
+completeValue outputType@(Out.ScalarBaseType _) _ _ (Type.Boolean boolean) =
+    coerceResult outputType $ Boolean boolean
+completeValue outputType@(Out.ScalarBaseType _) _ _ (Type.Float float) =
+    coerceResult outputType $ Float float
+completeValue outputType@(Out.ScalarBaseType _) _ _ (Type.String string) =
+    coerceResult outputType $ String string
+completeValue outputType@(Out.EnumBaseType enumType) _ _ (Type.Enum enum) =
+    let Type.EnumType _ _ enumMembers = enumType
+     in if HashMap.member enum enumMembers
+        then coerceResult outputType $ Enum enum
+        else throwM
+            $ ValueCompletionException (show outputType)
+            $ Type.Enum enum
+completeValue (Out.ObjectBaseType objectType) fields errorPath result
+    = executeSelectionSet (mergeSelectionSets fields) objectType result
+    $ fieldsSegment fields : errorPath
+completeValue outputType@(Out.InterfaceBaseType interfaceType) fields errorPath result
+    | Type.Object objectMap <- result = do
+        let abstractType = Type.Internal.AbstractInterfaceType interfaceType
+        concreteType <- resolveAbstractType abstractType objectMap
+        case concreteType of
+            Just objectType
+                -> executeSelectionSet (mergeSelectionSets fields) objectType result
+                $ fieldsSegment fields : errorPath
+            Nothing -> throwM
+                $ ValueCompletionException (show outputType) result
+completeValue outputType@(Out.UnionBaseType unionType) fields errorPath result
+    | Type.Object objectMap <- result = do
+        let abstractType = Type.Internal.AbstractUnionType unionType
+        concreteType <- resolveAbstractType abstractType objectMap
+        case concreteType of
+            Just objectType
+                -> executeSelectionSet (mergeSelectionSets fields) objectType result
+                $ fieldsSegment fields : errorPath
+            Nothing -> throwM
+                $ ValueCompletionException (show outputType) result
+completeValue outputType _ _ result =
+    throwM $ ValueCompletionException (show outputType) result
+
+coerceResult :: (MonadCatch m, Serialize a)
+    => Out.Type m
+    -> Output a
+    -> ExecutorT m a
+coerceResult outputType result
+    | Just serialized <- serialize outputType result = pure serialized
+    | otherwise = throwM $ ResultCoercionException $ show outputType
+
+mergeSelectionSets :: MonadCatch m
+    => NonEmpty (Transform.Field m)
+    -> Seq (Transform.Selection m)
+mergeSelectionSets = foldr forEach mempty
+  where
+    forEach (Transform.Field _ _ _ fieldSelectionSet _) selectionSet' =
+        selectionSet' <> fieldSelectionSet
+
+coerceArgumentValues :: MonadCatch m
+    => HashMap Full.Name In.Argument
+    -> HashMap Full.Name (Full.Node Transform.Input)
+    -> m Type.Subs
+coerceArgumentValues argumentDefinitions argumentValues =
+    HashMap.foldrWithKey c pure argumentDefinitions mempty
+  where
+    c argumentName argumentType pure' resultMap =
+        forEach argumentName argumentType resultMap >>= pure'
+    forEach :: MonadCatch m
+         => Full.Name
+         -> In.Argument
+         -> Type.Subs
+         -> m Type.Subs
+    forEach argumentName (In.Argument _ variableType defaultValue) resultMap = do
+        let matchedMap
+                = matchFieldValues' argumentName variableType defaultValue
+                $ Just resultMap
+         in case matchedMap of
+            Just matchedValues -> pure matchedValues
+            Nothing
+                | Just inputValue <- HashMap.lookup argumentName argumentValues
+                    -> throwM
+                    $ InputCoercionException (Text.unpack argumentName) variableType
+                    $ Just inputValue
+                | otherwise -> throwM
+                    $ InputCoercionException (Text.unpack argumentName) variableType Nothing
+    matchFieldValues' = matchFieldValues coerceArgumentValue
+        $ Full.node <$> argumentValues
+    coerceArgumentValue inputType (Transform.Int integer) =
+        coerceInputLiteral inputType (Type.Int integer)
+    coerceArgumentValue inputType (Transform.Boolean boolean) =
+        coerceInputLiteral inputType (Type.Boolean boolean)
+    coerceArgumentValue inputType (Transform.String string) =
+        coerceInputLiteral inputType (Type.String string)
+    coerceArgumentValue inputType (Transform.Float float) =
+        coerceInputLiteral inputType (Type.Float float)
+    coerceArgumentValue inputType (Transform.Enum enum) =
+        coerceInputLiteral inputType (Type.Enum enum)
+    coerceArgumentValue inputType Transform.Null
+        | In.isNonNullType inputType = Nothing
+        | otherwise = coerceInputLiteral inputType Type.Null
+    coerceArgumentValue (In.ListBaseType inputType) (Transform.List list) =
+        let coerceItem = coerceArgumentValue inputType
+         in Type.List <$> traverse coerceItem list
+    coerceArgumentValue (In.InputObjectBaseType inputType) (Transform.Object object)
+        | In.InputObjectType _ _ inputFields <- inputType = 
+            let go = forEachField object
+                resultMap = HashMap.foldrWithKey go (pure mempty) inputFields
+             in Type.Object <$> resultMap
+    coerceArgumentValue _ (Transform.Variable variable) = pure variable
+    coerceArgumentValue _ _ = Nothing
+    forEachField object variableName (In.InputField _ variableType defaultValue) =
+        matchFieldValues coerceArgumentValue object variableName variableType defaultValue
+
+collectFields :: Monad m
+    => Out.ObjectType m
+    -> Seq (Transform.Selection m)
+    -> OrderedMap (NonEmpty (Transform.Field m))
+collectFields objectType = foldl forEach OrderedMap.empty
+  where
+    forEach groupedFields (Transform.FieldSelection fieldSelection) =
+        let Transform.Field maybeAlias fieldName _ _ _ = fieldSelection
+            responseKey = fromMaybe fieldName maybeAlias
+         in OrderedMap.insert responseKey (fieldSelection :| []) groupedFields
+    forEach groupedFields (Transform.FragmentSelection selectionFragment)
+        | Transform.Fragment fragmentType fragmentSelectionSet _ <- selectionFragment
+        , Type.Internal.doesFragmentTypeApply fragmentType objectType =
+            let fragmentGroupedFieldSet =
+                    collectFields objectType fragmentSelectionSet
+             in groupedFields <> fragmentGroupedFieldSet
+        | otherwise = groupedFields
+
+coerceVariableValues :: (Monad m, VariableValue b)
+    => HashMap Full.Name (Schema.Type m)
+    -> Full.OperationDefinition
+    -> HashMap Full.Name b
+    -> Either QueryError Type.Subs
+coerceVariableValues types operationDefinition' variableValues
+    | Full.OperationDefinition _ _ variableDefinitions _ _ _ <-
+        operationDefinition'
+    = foldr forEach (Right HashMap.empty) variableDefinitions
+    | otherwise = pure mempty
+  where
+    forEach variableDefinition (Right coercedValues) =
+        let Full.VariableDefinition variableName variableTypeName defaultValue _ =
+                variableDefinition
+            defaultValue' = constValue . Full.node <$> defaultValue
+         in case Type.Internal.lookupInputType variableTypeName types of
+            Just variableType ->
+                maybe (Left $ CoercionError variableDefinition) Right
+                    $ matchFieldValues
+                        coerceVariableValue'
+                        variableValues
+                        variableName
+                        variableType
+                        defaultValue'
+                    $ Just coercedValues
+            Nothing -> Left $ UnknownInputType variableDefinition
+    forEach _ coercedValuesOrError = coercedValuesOrError
+    coerceVariableValue' variableType value'
+        = coerceVariableValue variableType value'
+        >>= coerceInputLiteral variableType
+
+constValue :: Full.ConstValue -> Type.Value
+constValue (Full.ConstInt i) = Type.Int i
+constValue (Full.ConstFloat f) = Type.Float f
+constValue (Full.ConstString x) = Type.String x
+constValue (Full.ConstBoolean b) = Type.Boolean b
+constValue Full.ConstNull = Type.Null
+constValue (Full.ConstEnum e) = Type.Enum e
+constValue (Full.ConstList list) = Type.List $ constValue . Full.node <$> list
+constValue (Full.ConstObject o) =
+    Type.Object $ HashMap.fromList $ constObjectField <$> o
+  where
+    constObjectField Full.ObjectField{value = value', ..} =
+        (name, constValue $ Full.node value')
+
+subscribe :: (MonadCatch m, Serialize a)
+    => Seq (Transform.Selection m)
+    -> Schema m
+    -> Full.Location
+    -> m (Either Error (ResponseEventStream m a))
+subscribe fields schema objectLocation
+    | Just objectType <- Schema.subscription schema = do
+        let types' = Schema.types schema
+        sourceStream <-
+            createSourceEventStream types' objectType objectLocation fields
+        let traverser =
+                mapSourceToResponseEvent types' objectType fields
+        traverse traverser sourceStream
+    | otherwise = pure $ Left
+        $ Error "Schema doesn't support subscriptions." [] []
+
+mapSourceToResponseEvent :: (MonadCatch m, Serialize a)
+    => HashMap Full.Name (Type m)
     -> Out.ObjectType m
     -> Seq (Transform.Selection m)
+    -> Out.SourceEventStream m
+    -> m (ResponseEventStream m a)
+mapSourceToResponseEvent types' subscriptionType fields sourceStream
+    = pure
+    $ sourceStream
+    .| mapMC (executeSubscriptionEvent types' subscriptionType fields)
+
+createSourceEventStream :: MonadCatch m
+    => HashMap Full.Name (Type m)
+    -> Out.ObjectType m
+    -> Full.Location
+    -> Seq (Transform.Selection m)
+    -> m (Either Error (Out.SourceEventStream m))
+createSourceEventStream _types subscriptionType objectLocation fields
+    | [fieldGroup] <- OrderedMap.elems groupedFieldSet
+    , Transform.Field _ fieldName arguments' _ errorLocation <-
+        NonEmpty.head fieldGroup
+    , Out.ObjectType _ _ _ fieldTypes <- subscriptionType
+    , resolverT <- fieldTypes HashMap.! fieldName
+    , Out.EventStreamResolver fieldDefinition _ resolver <- resolverT
+    , Out.Field _ _fieldType argumentDefinitions <- fieldDefinition =
+        case coerceArgumentValues argumentDefinitions arguments' of
+            Left _ -> pure
+                $ Left
+                $ Error "Argument coercion failed." [errorLocation] []
+            Right  argumentValues -> left (singleError [errorLocation])
+                <$> resolveFieldEventStream Type.Null argumentValues resolver
+    | otherwise = pure
+        $ Left
+        $ Error "Subscription contains more than one field." [objectLocation] []
+  where
+    groupedFieldSet = collectFields subscriptionType fields
+    singleError :: [Full.Location] -> String -> Error
+    singleError errorLocations message = Error (Text.pack message) errorLocations []
+
+resolveFieldEventStream :: MonadCatch m
+    => Type.Value
+    -> Type.Subs
+    -> Out.Subscribe m
+    -> m (Either String (Out.SourceEventStream m))
+resolveFieldEventStream result args resolver =
+    catch (Right <$> runReaderT resolver context) handleEventStreamError
+  where
+    handleEventStreamError :: MonadCatch m
+        => ResolverException
+        -> m (Either String (Out.SourceEventStream m))
+    handleEventStreamError = pure . Left . displayException
+    context = Type.Context
+        { Type.arguments = Type.Arguments args
+        , Type.values = result
+        }
+
+executeSubscriptionEvent :: (MonadCatch m, Serialize a)
+    => HashMap Full.Name (Type m)
+    -> Out.ObjectType m
+    -> Seq (Transform.Selection m)
+    -> Type.Value
     -> m (Response a)
-executeOperation types' objectType fields =
+executeSubscriptionEvent types' objectType fields initialValue = do
-    runCollectErrs types' $ executeSelectionSet Definition.Null objectType fields
+    (data', errors) <- runWriterT
+        $ flip runReaderT types'
+        $ runExecutorT
+        $ catch (executeSelectionSet fields objectType initialValue [])
+        handleException
+    pure $ Response data' errors

src/Language/GraphQL/Execute/Coerce.hs

@@ -19,7 +19,6 @@ import qualified Data.Aeson as Aeson
 import Data.Int (Int32)
 import Data.HashMap.Strict (HashMap)
 import qualified Data.HashMap.Strict as HashMap
-import Data.Map.Strict (Map)
 import Data.String (IsString(..))
 import Data.Text (Text)
 import qualified Data.Text.Lazy as Text.Lazy
@@ -27,6 +26,8 @@ import qualified Data.Text.Lazy.Builder as Text.Builder
 import qualified Data.Text.Lazy.Builder.Int as Text.Builder
 import Data.Scientific (toBoundedInteger, toRealFloat)
 import Language.GraphQL.AST (Name)
+import Language.GraphQL.Execute.OrderedMap (OrderedMap)
+import qualified Language.GraphQL.Execute.OrderedMap as OrderedMap
 import qualified Language.GraphQL.Type as Type
 import qualified Language.GraphQL.Type.In as In
 import qualified Language.GraphQL.Type.Out as Out
@@ -209,7 +210,7 @@ data Output a
     | Boolean Bool
     | Enum Name
     | List [a]
-    | Object (Map Name a)
+    | Object (OrderedMap a)
     deriving (Eq, Show)
 
 instance forall a. IsString (Output a) where
@@ -229,6 +230,9 @@ instance Serialize Aeson.Value where
         , Boolean boolean <- value = Just $ Aeson.Bool boolean
     serialize _ (Enum enum) = Just $ Aeson.String enum
     serialize _ (List list) = Just $ Aeson.toJSON list
-    serialize _ (Object object) = Just $ Aeson.toJSON object
+    serialize _ (Object object) = Just
+        $ Aeson.object
+        $ OrderedMap.toList
+        $ Aeson.toJSON <$> object
     serialize _ _ = Nothing
     null = Aeson.Null

src/Language/GraphQL/Execute/Execution.hs

@@ -1,216 +0,0 @@
-{-# LANGUAGE ExplicitForAll #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE ViewPatterns #-}
-
-module Language.GraphQL.Execute.Execution
-    ( coerceArgumentValues
-    , collectFields
-    , executeSelectionSet
-    ) where
-
-import Control.Monad.Catch (Exception(..), MonadCatch(..))
-import Control.Monad.Trans.Class (lift)
-import Control.Monad.Trans.Reader (runReaderT)
-import Control.Monad.Trans.State (gets)
-import Data.List.NonEmpty (NonEmpty(..))
-import Data.Map.Strict (Map)
-import Data.HashMap.Strict (HashMap)
-import qualified Data.HashMap.Strict as HashMap
-import qualified Data.Map.Strict as Map
-import Data.Maybe (fromMaybe)
-import Data.Sequence (Seq(..))
-import qualified Data.Text as Text
-import Language.GraphQL.AST (Name)
-import Language.GraphQL.Error
-import Language.GraphQL.Execute.Coerce
-import qualified Language.GraphQL.Execute.Transform as Transform
-import qualified Language.GraphQL.Type as Type
-import qualified Language.GraphQL.Type.In as In
-import qualified Language.GraphQL.Type.Out as Out
-import qualified Language.GraphQL.Type.Internal as Internal
-import Prelude hiding (null)
-
-resolveFieldValue :: MonadCatch m
-    => Type.Value
-    -> Type.Subs
-    -> Type.Resolve m
-    -> CollectErrsT m Type.Value
-resolveFieldValue result args resolver =
-    catch (lift $ runReaderT resolver context) handleFieldError
-  where
-    handleFieldError :: MonadCatch m
-        => ResolverException
-        -> CollectErrsT m Type.Value
-    handleFieldError e =
-        addErr (Error (Text.pack $ displayException e) [] []) >> pure Type.Null
-    context = Type.Context
-        { Type.arguments = Type.Arguments args
-        , Type.values = result
-        }
-
-collectFields :: Monad m
-    => Out.ObjectType m
-    -> Seq (Transform.Selection m)
-    -> Map Name (NonEmpty (Transform.Field m))
-collectFields objectType = foldl forEach Map.empty
-  where
-    forEach groupedFields (Transform.SelectionField field) =
-        let responseKey = aliasOrName field
-         in Map.insertWith (<>) responseKey (field :| []) groupedFields
-    forEach groupedFields (Transform.SelectionFragment selectionFragment)
-        | Transform.Fragment fragmentType fragmentSelectionSet <- selectionFragment
-        , Internal.doesFragmentTypeApply fragmentType objectType =
-            let fragmentGroupedFieldSet = collectFields objectType fragmentSelectionSet
-             in Map.unionWith (<>) groupedFields fragmentGroupedFieldSet
-        | otherwise = groupedFields
-
-aliasOrName :: forall m. Transform.Field m -> Name
-aliasOrName (Transform.Field alias name _ _) = fromMaybe name alias
-
-resolveAbstractType :: Monad m
-    => Internal.AbstractType m
-    -> Type.Subs
-    -> CollectErrsT m (Maybe (Out.ObjectType m))
-resolveAbstractType abstractType values'
-    | Just (Type.String typeName) <- HashMap.lookup "__typename" values' = do
-        types' <- gets types
-        case HashMap.lookup typeName types' of
-            Just (Internal.ObjectType objectType) ->
-                if Internal.instanceOf objectType abstractType
-                    then pure $ Just objectType
-                    else pure Nothing
-            _ -> pure Nothing
-    | otherwise = pure Nothing
-
-executeField :: (MonadCatch m, Serialize a)
-    => Out.Resolver m
-    -> Type.Value
-    -> NonEmpty (Transform.Field m)
-    -> CollectErrsT m a
-executeField fieldResolver prev fields
-    | Out.ValueResolver fieldDefinition resolver <- fieldResolver =
-        executeField' fieldDefinition resolver
-    | Out.EventStreamResolver fieldDefinition resolver _ <- fieldResolver =
-        executeField' fieldDefinition resolver
-  where
-    executeField' fieldDefinition resolver = do
-        let Out.Field _ fieldType argumentDefinitions = fieldDefinition
-        let (Transform.Field _ _ arguments' _ :| []) = fields
-        case coerceArgumentValues argumentDefinitions arguments' of
-            Nothing -> addErrMsg "Argument coercing failed."
-            Just argumentValues -> do
-                answer <- resolveFieldValue prev argumentValues resolver
-                completeValue fieldType fields answer
-
-completeValue :: (MonadCatch m, Serialize a)
-    => Out.Type m
-    -> NonEmpty (Transform.Field m)
-    -> Type.Value
-    -> CollectErrsT m a
-completeValue (Out.isNonNullType -> False) _ Type.Null = pure null
-completeValue outputType@(Out.ListBaseType listType) fields (Type.List list)
-    = traverse (completeValue listType fields) list
-    >>= coerceResult outputType . List
-completeValue outputType@(Out.ScalarBaseType _) _ (Type.Int int) =
-    coerceResult outputType $ Int int
-completeValue outputType@(Out.ScalarBaseType _) _ (Type.Boolean boolean) =
-    coerceResult outputType $ Boolean boolean
-completeValue outputType@(Out.ScalarBaseType _) _ (Type.Float float) =
-    coerceResult outputType $ Float float
-completeValue outputType@(Out.ScalarBaseType _) _ (Type.String string) =
-    coerceResult outputType $ String string
-completeValue outputType@(Out.EnumBaseType enumType) _ (Type.Enum enum) =
-    let Type.EnumType _ _ enumMembers = enumType
-     in if HashMap.member enum enumMembers
-        then coerceResult outputType $ Enum enum
-        else addErrMsg "Enum value completion failed."
-completeValue (Out.ObjectBaseType objectType) fields result =
-    executeSelectionSet result objectType $ mergeSelectionSets fields
-completeValue (Out.InterfaceBaseType interfaceType) fields result
-    | Type.Object objectMap <- result = do
-        let abstractType = Internal.AbstractInterfaceType interfaceType
-        concreteType <- resolveAbstractType abstractType objectMap
-        case concreteType of
-            Just objectType -> executeSelectionSet result objectType
-                $ mergeSelectionSets fields
-            Nothing -> addErrMsg "Interface value completion failed."
-completeValue (Out.UnionBaseType unionType) fields result
-    | Type.Object objectMap <- result = do
-        let abstractType = Internal.AbstractUnionType unionType
-        concreteType <- resolveAbstractType abstractType objectMap
-        case concreteType of
-            Just objectType -> executeSelectionSet result objectType
-                $ mergeSelectionSets fields
-            Nothing -> addErrMsg "Union value completion failed."
-completeValue _ _ _ = addErrMsg "Value completion failed."
-
-mergeSelectionSets :: MonadCatch m
-    => NonEmpty (Transform.Field m)
-    -> Seq (Transform.Selection m)
-mergeSelectionSets = foldr forEach mempty
-  where
-    forEach (Transform.Field _ _ _ fieldSelectionSet) selectionSet =
-        selectionSet <> fieldSelectionSet
-
-coerceResult :: (MonadCatch m, Serialize a)
-    => Out.Type m
-    -> Output a
-    -> CollectErrsT m a
-coerceResult outputType result
-    | Just serialized <- serialize outputType result = pure serialized
-    | otherwise = addErrMsg "Result coercion failed."
-
--- | Takes an 'Out.ObjectType' and a list of 'Transform.Selection's and applies
--- each field to each 'Transform.Selection'. Resolves into a value containing
--- the resolved 'Transform.Selection', or a null value and error information.
-executeSelectionSet :: (MonadCatch m, Serialize a)
-    => Type.Value
-    -> Out.ObjectType m
-    -> Seq (Transform.Selection m)
-    -> CollectErrsT m a
-executeSelectionSet result objectType@(Out.ObjectType _ _ _ resolvers) selectionSet = do
-    let fields = collectFields objectType selectionSet
-    resolvedValues <- Map.traverseMaybeWithKey forEach fields
-    coerceResult (Out.NonNullObjectType objectType) $ Object resolvedValues
-  where
-    forEach _ fields@(field :| _) =
-        let Transform.Field _ name _ _ = field
-         in traverse (tryResolver fields) $ lookupResolver name
-    lookupResolver = flip HashMap.lookup resolvers
-    tryResolver fields resolver =
-        executeField resolver result fields >>= lift . pure
-
-coerceArgumentValues
-    :: HashMap Name In.Argument
-    -> HashMap Name Transform.Input
-    -> Maybe Type.Subs
-coerceArgumentValues argumentDefinitions argumentValues =
-    HashMap.foldrWithKey forEach (pure mempty) argumentDefinitions
-  where
-    forEach variableName (In.Argument _ variableType defaultValue) =
-        matchFieldValues coerceArgumentValue argumentValues variableName variableType defaultValue
-    coerceArgumentValue inputType (Transform.Int integer) =
-        coerceInputLiteral inputType (Type.Int integer)
-    coerceArgumentValue inputType (Transform.Boolean boolean) =
-        coerceInputLiteral inputType (Type.Boolean boolean)
-    coerceArgumentValue inputType (Transform.String string) =
-        coerceInputLiteral inputType (Type.String string)
-    coerceArgumentValue inputType (Transform.Float float) =
-        coerceInputLiteral inputType (Type.Float float)
-    coerceArgumentValue inputType (Transform.Enum enum) =
-        coerceInputLiteral inputType (Type.Enum enum)
-    coerceArgumentValue inputType Transform.Null
-        | In.isNonNullType inputType = Nothing
-        | otherwise = coerceInputLiteral inputType Type.Null
-    coerceArgumentValue (In.ListBaseType inputType) (Transform.List list) =
-        let coerceItem = coerceInputLiteral inputType
-         in Type.List <$> traverse coerceItem list
-    coerceArgumentValue (In.InputObjectBaseType inputType) (Transform.Object object)
-        | In.InputObjectType _ _ inputFields <- inputType = 
-            let go = forEachField object
-                resultMap = HashMap.foldrWithKey go (pure mempty) inputFields
-             in Type.Object <$> resultMap
-    coerceArgumentValue _ (Transform.Variable variable) = pure variable
-    coerceArgumentValue _ _ = Nothing
-    forEachField object variableName (In.InputField _ variableType defaultValue) =
-        matchFieldValues coerceArgumentValue object variableName variableType defaultValue

src/Language/GraphQL/Execute/OrderedMap.hs

@@ -0,0 +1,148 @@
+{- This Source Code Form is subject to the terms of the Mozilla Public License,
+   v. 2.0. If a copy of the MPL was not distributed with this file, You can
+   obtain one at https://mozilla.org/MPL/2.0/. -}
+
+{-# LANGUAGE ExplicitForAll #-}
+
+-- | This module contains a map data structure, that preserves insertion order.
+-- Some definitions conflict with functions from prelude, so this module should
+-- probably be imported qualified.
+module Language.GraphQL.Execute.OrderedMap
+    ( OrderedMap
+    , elems
+    , empty
+    , insert
+    , foldlWithKey'
+    , keys
+    , lookup
+    , replace
+    , singleton
+    , size
+    , toList
+    , traverseMaybe
+    ) where
+
+import qualified Data.Foldable as Foldable
+import Data.HashMap.Strict (HashMap, (!))
+import qualified Data.HashMap.Strict as HashMap
+import Data.Text (Text)
+import Data.Vector (Vector)
+import qualified Data.Vector as Vector
+import Prelude hiding (filter, lookup)
+
+-- | This map associates values with the given text keys. Insertion order is
+-- preserved. When inserting a value with a key, that is already available in
+-- the map, the existing value isn't overridden, but combined with the new value
+-- using its 'Semigroup' instance.
+--
+-- Internally this map uses an array with keys to preserve the order and an
+-- unorded map with key-value pairs.
+data OrderedMap v = OrderedMap (Vector Text) (HashMap Text v)
+    deriving (Eq)
+
+instance Functor OrderedMap where
+    fmap f (OrderedMap vector hashMap) = OrderedMap vector $ fmap f hashMap
+
+instance Foldable OrderedMap where
+    foldr f = foldrWithKey $ const f
+    null (OrderedMap vector _) = Vector.null vector
+
+instance Semigroup v => Semigroup (OrderedMap v) where
+    (<>) = foldlWithKey'
+        $ \accumulator key value -> insert key value accumulator
+
+instance Semigroup v => Monoid (OrderedMap v) where
+    mempty = empty
+
+instance Traversable OrderedMap where
+    traverse f (OrderedMap vector hashMap) = OrderedMap vector
+        <$> traverse f hashMap
+
+instance Show v => Show (OrderedMap v) where
+    showsPrec precedence map' = showParen (precedence > 10)
+        $ showString "fromList " . shows (toList map')
+
+-- * Construction
+
+-- | Constructs a map with a single element.
+singleton :: forall v. Text -> v -> OrderedMap v
+singleton key value = OrderedMap (Vector.singleton key)
+    $ HashMap.singleton key value
+
+-- | Constructs an empty map.
+empty :: forall v. OrderedMap v
+empty = OrderedMap mempty mempty
+
+-- * Traversal
+
+-- | Reduces this map by applying a binary operator from right to left to all
+-- elements, using the given starting value.
+foldrWithKey :: forall v a. (Text -> v -> a -> a) -> a -> OrderedMap v -> a
+foldrWithKey f initial (OrderedMap vector hashMap) = foldr go initial vector
+  where
+    go key = f key (hashMap ! key)
+
+-- | Reduces this map by applying a binary operator from left to right to all
+-- elements, using the given starting value.
+foldlWithKey' :: forall v a. (a -> Text -> v -> a) -> a -> OrderedMap v -> a
+foldlWithKey' f initial (OrderedMap vector hashMap) =
+    Vector.foldl' go initial vector
+  where
+    go accumulator key = f accumulator key (hashMap ! key)
+
+-- | Traverse over the elements and collect the 'Just' results.
+traverseMaybe
+    :: Applicative f
+    => forall a
+    . (a -> f (Maybe b))
+    -> OrderedMap a
+    -> f (OrderedMap b)
+traverseMaybe f orderedMap = foldlWithKey' filter empty
+    <$> traverse f orderedMap
+  where
+    filter accumulator key (Just value) = replace key value accumulator
+    filter accumulator _ Nothing = accumulator
+
+-- * Lists
+
+-- | Converts this map to the list of key-value pairs.
+toList :: forall v. OrderedMap v -> [(Text, v)]
+toList = foldrWithKey ((.) (:) . (,)) []
+
+-- | Returns a list with all keys in this map.
+keys :: forall v. OrderedMap v -> [Text]
+keys (OrderedMap vector _) = Foldable.toList vector
+
+-- | Returns a list with all elements in this map.
+elems :: forall v. OrderedMap v -> [v]
+elems = fmap snd . toList
+
+-- * Basic interface
+
+-- | Associates the specified value with the specified key in this map. If this
+-- map previously contained a mapping for the key, the existing and new values
+-- are combined.
+insert :: Semigroup v => Text -> v -> OrderedMap v -> OrderedMap v
+insert key value (OrderedMap vector hashMap)
+    | Just available <- HashMap.lookup key hashMap = OrderedMap vector
+        $ HashMap.insert key (available <> value) hashMap
+    | otherwise = OrderedMap (Vector.snoc vector key)
+        $ HashMap.insert key value hashMap
+
+-- | Associates the specified value with the specified key in this map. If this
+-- map previously contained a mapping for the key, the existing value is
+-- replaced by the new one.
+replace :: Text -> v -> OrderedMap v -> OrderedMap v
+replace key value (OrderedMap vector hashMap)
+    | HashMap.member key hashMap = OrderedMap vector
+        $ HashMap.insert key value hashMap
+    | otherwise = OrderedMap (Vector.snoc vector key)
+        $ HashMap.insert key value hashMap
+
+-- | Gives the size of this map, i.e. number of elements in it.
+size :: forall v. OrderedMap v -> Int
+size (OrderedMap vector _) = Vector.length vector
+
+-- | Looks up a value in this map by key.
+lookup :: forall v. Text -> OrderedMap v -> Maybe v
+lookup key (OrderedMap _ hashMap) = HashMap.lookup key hashMap

src/Language/GraphQL/Execute/Subscribe.hs

@@ -1,97 +0,0 @@
-{- This Source Code Form is subject to the terms of the Mozilla Public License,
-   v. 2.0. If a copy of the MPL was not distributed with this file, You can
-   obtain one at https://mozilla.org/MPL/2.0/. -}
-
-{-# LANGUAGE ExplicitForAll #-}
-{-# LANGUAGE OverloadedStrings #-}
-module Language.GraphQL.Execute.Subscribe
-    ( subscribe
-    ) where
-
-import Conduit
-import Control.Monad.Catch (Exception(..), MonadCatch(..))
-import Control.Monad.Trans.Reader (ReaderT(..), runReaderT)
-import Data.HashMap.Strict (HashMap)
-import qualified Data.HashMap.Strict as HashMap
-import qualified Data.Map.Strict as Map
-import qualified Data.List.NonEmpty as NonEmpty
-import Data.Sequence (Seq(..))
-import Data.Text (Text)
-import qualified Data.Text as Text
-import Language.GraphQL.AST (Name)
-import Language.GraphQL.Execute.Coerce
-import Language.GraphQL.Execute.Execution
-import qualified Language.GraphQL.Execute.Transform as Transform
-import Language.GraphQL.Error
-import qualified Language.GraphQL.Type.Definition as Definition
-import qualified Language.GraphQL.Type as Type
-import qualified Language.GraphQL.Type.Out as Out
-import Language.GraphQL.Type.Schema
-
--- This is actually executeMutation, but we don't distinguish between queries
--- and mutations yet.
-subscribe :: (MonadCatch m, Serialize a)
-    => HashMap Name (Type m)
-    -> Out.ObjectType m
-    -> Seq (Transform.Selection m)
-    -> m (Either Text (ResponseEventStream m a))
-subscribe types' objectType fields = do
-    sourceStream <- createSourceEventStream types' objectType fields
-    traverse (mapSourceToResponseEvent types' objectType fields) sourceStream
-
-mapSourceToResponseEvent :: (MonadCatch m, Serialize a)
-    => HashMap Name (Type m)
-    -> Out.ObjectType m
-    -> Seq (Transform.Selection m)
-    -> Out.SourceEventStream m
-    -> m (ResponseEventStream m a)
-mapSourceToResponseEvent types' subscriptionType fields sourceStream = pure
-    $ sourceStream
-    .| mapMC (executeSubscriptionEvent types' subscriptionType fields)
-
-createSourceEventStream :: MonadCatch m
-    => HashMap Name (Type m)
-    -> Out.ObjectType m
-    -> Seq (Transform.Selection m)
-    -> m (Either Text (Out.SourceEventStream m))
-createSourceEventStream _types subscriptionType@(Out.ObjectType _ _ _ fieldTypes) fields
-    | [fieldGroup] <- Map.elems groupedFieldSet
-    , Transform.Field _ fieldName arguments' _ <- NonEmpty.head fieldGroup
-    , resolverT <- fieldTypes HashMap.! fieldName
-    , Out.EventStreamResolver fieldDefinition _ resolver <- resolverT
-    , Out.Field _ _fieldType argumentDefinitions <- fieldDefinition =
-        case coerceArgumentValues argumentDefinitions arguments' of
-            Nothing -> pure $ Left "Argument coercion failed."
-            Just argumentValues ->
-                resolveFieldEventStream Type.Null argumentValues resolver
-    | otherwise = pure $ Left "Subscription contains more than one field."
-  where
-    groupedFieldSet = collectFields subscriptionType fields
-
-resolveFieldEventStream :: MonadCatch m
-    => Type.Value
-    -> Type.Subs
-    -> Out.Subscribe m
-    -> m (Either Text (Out.SourceEventStream m))
-resolveFieldEventStream result args resolver =
-    catch (Right <$> runReaderT resolver context) handleEventStreamError
-  where
-    handleEventStreamError :: MonadCatch m
-        => ResolverException
-        -> m (Either Text (Out.SourceEventStream m))
-    handleEventStreamError = pure . Left . Text.pack . displayException
-    context = Type.Context
-        { Type.arguments = Type.Arguments args
-        , Type.values = result
-        }
-
--- This is actually executeMutation, but we don't distinguish between queries
--- and mutations yet.
-executeSubscriptionEvent :: (MonadCatch m, Serialize a)
-    => HashMap Name (Type m)
-    -> Out.ObjectType m
-    -> Seq (Transform.Selection m)
-    -> Definition.Value
-    -> m (Response a)
-executeSubscriptionEvent types' objectType fields initialValue =
-    runCollectErrs types' $ executeSelectionSet initialValue objectType fields

src/Language/GraphQL/Execute/Transform.hs

@@ -1,8 +1,12 @@
+{- This Source Code Form is subject to the terms of the Mozilla Public License,
+   v. 2.0. If a copy of the MPL was not distributed with this file, You can
+   obtain one at https://mozilla.org/MPL/2.0/. -}
+
 {-# LANGUAGE ExplicitForAll #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE TupleSections #-}
+{-# LANGUAGE NamedFieldPuns #-}
 
 -- | After the document is parsed, before getting executed, the AST is
 -- transformed into a similar, simpler AST. Performed transformations include:
@@ -17,400 +21,305 @@
 -- This module is also responsible for smaller rewrites that touch only parts of
 -- the original AST.
 module Language.GraphQL.Execute.Transform
-    ( Document(..)
+    ( Field(..)
-    , Field(..)
     , Fragment(..)
     , Input(..)
     , Operation(..)
-    , QueryError(..)
+    , Replacement(..)
     , Selection(..)
+    , TransformT(..)
     , document
-    , queryError
+    , transform
     ) where
 
-import Control.Monad (foldM, unless)
+import Control.Monad (foldM)
-import Control.Monad.Trans.Class (lift)
+import Control.Monad.Catch (MonadCatch(..), MonadThrow(..))
-import Control.Monad.Trans.State (State, evalStateT, gets, modify)
+import Control.Monad.Trans.Class (MonadTrans(..))
-import Data.Foldable (find)
+import Control.Monad.Trans.Reader (ReaderT(..), local)
-import Data.Functor.Identity (Identity(..))
+import qualified Control.Monad.Trans.Reader as Reader
+import Data.Bifunctor (first)
+import Data.Functor ((<&>))
 import Data.HashMap.Strict (HashMap)
 import qualified Data.HashMap.Strict as HashMap
+import Data.HashSet (HashSet)
+import qualified Data.HashSet as HashSet
 import Data.Int (Int32)
-import Data.Maybe (fromMaybe)
+import Data.List (intercalate)
-import Data.List.NonEmpty (NonEmpty(..))
 import qualified Data.List.NonEmpty as NonEmpty
-import Data.Sequence (Seq, (<|), (><))
+import Data.Maybe (fromMaybe, isJust)
+import Data.Sequence (Seq, (><))
+import qualified Data.Sequence as Seq
 import Data.Text (Text)
 import qualified Data.Text as Text
-import qualified Language.GraphQL.AST as Full
+import qualified Language.GraphQL.AST.Document as Full
-import Language.GraphQL.AST (Name)
+import Language.GraphQL.Type.Schema (Type)
-import qualified Language.GraphQL.Execute.Coerce as Coerce
-import qualified Language.GraphQL.Type.Definition as Definition
 import qualified Language.GraphQL.Type as Type
+import qualified Language.GraphQL.Type.Definition as Definition
 import qualified Language.GraphQL.Type.Internal as Type
-import qualified Language.GraphQL.Type.Out as Out
+import Numeric (showFloat)
-import qualified Language.GraphQL.Type.Schema as Schema
 
 -- | Associates a fragment name with a list of 'Field's.
 data Replacement m = Replacement
-    { fragments :: HashMap Full.Name (Fragment m)
+    { variableValues :: Type.Subs
-    , fragmentDefinitions :: FragmentDefinitions
+    , fragmentDefinitions :: HashMap Full.Name Full.FragmentDefinition
-    , variableValues :: Type.Subs
+    , visitedFragments :: HashSet Full.Name
-    , types :: HashMap Full.Name (Schema.Type m)
+    , types :: HashMap Full.Name (Type m)
     }
 
-type FragmentDefinitions = HashMap Full.Name Full.FragmentDefinition
+newtype TransformT m a = TransformT
+    { runTransformT :: ReaderT (Replacement m) m a
+    }
 
--- | Represents fragments and inline fragments.
+instance Functor m => Functor (TransformT m) where
-data Fragment m
+    fmap f = TransformT . fmap f . runTransformT
-    = Fragment (Type.CompositeType m) (Seq (Selection m))
 
--- | Single selection element.
+instance Applicative m => Applicative (TransformT m) where
-data Selection m
+    pure = TransformT . pure
-    = SelectionFragment (Fragment m)
+    TransformT f <*> TransformT x = TransformT $ f <*> x
-    | SelectionField (Field m)
+
+instance Monad m => Monad (TransformT m) where
+    TransformT x >>= f = TransformT $ x >>= runTransformT . f
+
+instance MonadTrans TransformT where
+    lift = TransformT . lift
+
+instance MonadThrow m => MonadThrow (TransformT m) where
+    throwM = lift . throwM
+
+instance MonadCatch m => MonadCatch (TransformT m) where
+  catch (TransformT stack) handler =
+      TransformT $ catch stack $ runTransformT . handler
+
+asks :: Monad m => forall a. (Replacement m -> a) -> TransformT m a
+asks = TransformT . Reader.asks
 
 -- | GraphQL has 3 operation types: queries, mutations and subscribtions.
---
--- Currently only queries and mutations are supported.
 data Operation m
-    = Query (Maybe Text) (Seq (Selection m))
+    = Operation Full.OperationType (Seq (Selection m)) Full.Location
-    | Mutation (Maybe Text) (Seq (Selection m))
+
-    | Subscription (Maybe Text) (Seq (Selection m))
+-- | Field or inlined fragment.
+data Selection m
+    = FieldSelection (Field m)
+    | FragmentSelection (Fragment m)
 
--- | Single GraphQL field.
 data Field m = Field
-    (Maybe Full.Name) Full.Name (HashMap Full.Name Input) (Seq (Selection m))
-
--- | Contains the operation to be executed along with its root type.
-data Document m = Document
-    (HashMap Full.Name (Schema.Type m)) (Out.ObjectType m) (Operation m)
-
-data OperationDefinition = OperationDefinition
-    Full.OperationType
     (Maybe Full.Name)
-    [Full.VariableDefinition]
+    Full.Name
-    [Full.Directive]
+    (HashMap Full.Name (Full.Node Input))
-    Full.SelectionSet
+    (Seq (Selection m))
+    Full.Location
 
--- | Query error types.
+data Fragment m = Fragment
-data QueryError
+    (Type.CompositeType m) (Seq (Selection m)) Full.Location
-    = OperationNotFound Text
-    | OperationNameRequired
-    | CoercionError
-    | TransformationError
-    | EmptyDocument
-    | UnsupportedRootOperation
 
 data Input
-    = Int Int32
+    = Variable Type.Value
+    | Int Int32
     | Float Double
     | String Text
     | Boolean Bool
     | Null
-    | Enum Name
+    | Enum Full.Name
-    | List [Type.Value]
+    | List [Input]
-    | Object (HashMap Name Input)
+    | Object (HashMap Full.Name Input)
-    | Variable Type.Value
+    deriving Eq
-    deriving (Eq, Show)
 
-queryError :: QueryError -> Text
+instance Show Input where
-queryError (OperationNotFound operationName) = Text.unwords
+    showList = mappend . showList'
-    ["Operation", operationName, "couldn't be found in the document."]
+      where
-queryError OperationNameRequired = "Missing operation name."
+        showList' list = "[" ++ intercalate ", " (show <$> list) ++ "]"
-queryError CoercionError = "Coercion error."
+    show (Int integer) = show integer
-queryError TransformationError = "Schema transformation error."
+    show (Float float') = showFloat float' mempty
-queryError EmptyDocument =
+    show (String text) = "\"" <> Text.foldr (mappend . Full.escape) "\"" text
-    "The document doesn't contain any executable operations."
+    show (Boolean boolean') = show boolean'
-queryError UnsupportedRootOperation =
+    show Null = "null"
-    "Root operation type couldn't be found in the schema."
+    show (Enum name) = Text.unpack name
+    show (List list) = show list
+    show (Object fields) = unwords
+        [ "{"
+        , intercalate ", " (HashMap.foldrWithKey showObject [] fields)
+        , "}"
+        ]
+      where
+        showObject key value accumulator =
+            concat [Text.unpack key, ": ", show value] : accumulator
+    show variableValue = show variableValue
 
-getOperation
+-- | Extracts operations and fragment definitions of the document.
-    :: Maybe Full.Name
+document :: Full.Document
-    -> NonEmpty OperationDefinition
+    -> ([Full.OperationDefinition], HashMap Full.Name Full.FragmentDefinition)
-    -> Either QueryError OperationDefinition
+document = foldr filterOperation ([], HashMap.empty)
-getOperation Nothing (operation' :| []) = pure operation'
-getOperation Nothing _ = Left OperationNameRequired
-getOperation (Just operationName) operations
-    | Just operation' <- find matchingName operations = pure operation'
-    | otherwise = Left $ OperationNotFound operationName
   where
-    matchingName (OperationDefinition _ name _ _ _) =
+    filterOperation (Full.ExecutableDefinition executableDefinition) accumulator
-        name == Just operationName
+        | Full.DefinitionOperation operationDefinition' <- executableDefinition =
-
+            first (operationDefinition' :) accumulator
-coerceVariableValues :: Coerce.VariableValue a
+        | Full.DefinitionFragment fragmentDefinition <- executableDefinition
-    => forall m
+        , Full.FragmentDefinition fragmentName _ _ _ _ <- fragmentDefinition =
-    . HashMap Full.Name (Schema.Type m)
+            HashMap.insert fragmentName fragmentDefinition <$> accumulator
-    -> OperationDefinition
+    filterOperation _ accumulator = accumulator -- Type system definitions.
-    -> HashMap.HashMap Full.Name a
-    -> Either QueryError Type.Subs
-coerceVariableValues types operationDefinition variableValues =
-    let OperationDefinition _ _ variableDefinitions _ _ = operationDefinition
-     in maybe (Left CoercionError) Right
-        $ foldr forEach (Just HashMap.empty) variableDefinitions
-  where
-    forEach variableDefinition coercedValues = do
-        let Full.VariableDefinition variableName variableTypeName defaultValue _ =
-                variableDefinition
-        let defaultValue' = constValue . Full.node <$> defaultValue
-        variableType <- Type.lookupInputType variableTypeName types
-
-        Coerce.matchFieldValues
-            coerceVariableValue'
-            variableValues
-            variableName
-            variableType
-            defaultValue'
-            coercedValues
-    coerceVariableValue' variableType value'
-        = Coerce.coerceVariableValue variableType value'
-        >>= Coerce.coerceInputLiteral variableType
-
-constValue :: Full.ConstValue -> Type.Value
-constValue (Full.ConstInt i) = Type.Int i
-constValue (Full.ConstFloat f) = Type.Float f
-constValue (Full.ConstString x) = Type.String x
-constValue (Full.ConstBoolean b) = Type.Boolean b
-constValue Full.ConstNull = Type.Null
-constValue (Full.ConstEnum e) = Type.Enum e
-constValue (Full.ConstList l) = Type.List $ constValue <$> l
-constValue (Full.ConstObject o) =
-    Type.Object $ HashMap.fromList $ constObjectField <$> o
-  where
-    constObjectField Full.ObjectField{value = value', ..} =
-        (name, constValue $ Full.node value')
 
 -- | Rewrites the original syntax tree into an intermediate representation used
--- for query execution.
+-- for the query execution.
-document :: Coerce.VariableValue a
+transform :: Monad m => Full.OperationDefinition -> TransformT m (Operation m)
-    => forall m
+transform (Full.OperationDefinition operationType _ _ _ selectionSet' operationLocation) = do
-    . Type.Schema m
+    transformedSelections <- selectionSet selectionSet'
-    -> Maybe Full.Name
+    pure $ Operation operationType transformedSelections operationLocation
+transform (Full.SelectionSet selectionSet' operationLocation) = do
+    transformedSelections <- selectionSet selectionSet'
+    pure $ Operation Full.Query transformedSelections operationLocation
+
+selectionSet :: Monad m => Full.SelectionSet -> TransformT m (Seq (Selection m))
+selectionSet = selectionSetOpt . NonEmpty.toList
+
+selectionSetOpt :: Monad m => Full.SelectionSetOpt -> TransformT m (Seq (Selection m))
+selectionSetOpt = foldM go Seq.empty
+  where
+    go accumulatedSelections currentSelection =
+        selection currentSelection <&> (accumulatedSelections ><)
+
+selection :: Monad m => Full.Selection -> TransformT m (Seq (Selection m))
+selection (Full.FieldSelection field') =
+    maybeToSelectionSet FieldSelection $ field field'
+selection (Full.FragmentSpreadSelection fragmentSpread') =
+    maybeToSelectionSet FragmentSelection $ fragmentSpread fragmentSpread'
+selection (Full.InlineFragmentSelection inlineFragment') =
+    either id (pure . FragmentSelection) <$> inlineFragment inlineFragment'
+
+maybeToSelectionSet :: Monad m
+    => forall a
+    . (a -> Selection m)
+    -> TransformT m (Maybe a)
+    -> TransformT m (Seq (Selection m))
+maybeToSelectionSet selectionType = fmap (maybe Seq.empty $ pure . selectionType)
+
+directives :: Monad m => [Full.Directive] -> TransformT m (Maybe [Definition.Directive])
+directives = fmap Type.selection . traverse directive
+
+inlineFragment :: Monad m
+    => Full.InlineFragment
+    -> TransformT m (Either (Seq (Selection m)) (Fragment m))
+inlineFragment (Full.InlineFragment maybeCondition directives' selectionSet' location)
+    | Just typeCondition <- maybeCondition = do
+        transformedSelections <- selectionSet selectionSet'
+        transformedDirectives <- directives directives'
+        maybeFragmentType <- asks
+            $ Type.lookupTypeCondition typeCondition
+            . types
+        pure $ case transformedDirectives >> maybeFragmentType of
+            Just fragmentType -> Right
+                $ Fragment fragmentType transformedSelections location
+            Nothing -> Left Seq.empty
+    | otherwise = do
+        transformedSelections <- selectionSet selectionSet'
+        transformedDirectives <- directives directives'
+        pure $ if isJust transformedDirectives
+            then Left transformedSelections
+            else Left Seq.empty
+
+fragmentSpread :: Monad m => Full.FragmentSpread -> TransformT m (Maybe (Fragment m))
+fragmentSpread (Full.FragmentSpread spreadName directives' location) = do
+    transformedDirectives <- directives directives'
+    visitedFragment <- asks $ HashSet.member spreadName . visitedFragments
+    possibleFragmentDefinition <- asks
+        $ HashMap.lookup spreadName
+        . fragmentDefinitions
+    case transformedDirectives >> possibleFragmentDefinition of
+        Just (Full.FragmentDefinition _ typeCondition _ selections _)
+            | visitedFragment -> pure Nothing
+            | otherwise -> do
+                fragmentType <- asks
+                    $ Type.lookupTypeCondition typeCondition
+                    . types
+                traverse (traverseSelections selections) fragmentType
+        Nothing -> pure Nothing
+  where
+    traverseSelections selections typeCondition = do
+        transformedSelections <- TransformT
+            $ local fragmentInserter
+            $ runTransformT
+            $ selectionSet selections
+        pure $ Fragment typeCondition transformedSelections location
+    fragmentInserter replacement@Replacement{ visitedFragments } = replacement
+        { visitedFragments = HashSet.insert spreadName visitedFragments }
+
+field :: Monad m => Full.Field -> TransformT m (Maybe (Field m))
+field (Full.Field alias' name' arguments' directives' selectionSet' location') = do
+    transformedSelections <- selectionSetOpt selectionSet'
+    transformedDirectives <- directives directives'
+    transformedArguments <- arguments arguments'
+    let transformedField = Field
+            alias'
+            name'
+            transformedArguments
+            transformedSelections
+            location'
+    pure $ transformedDirectives >> pure transformedField
+
+arguments :: Monad m => [Full.Argument] -> TransformT m (HashMap Full.Name (Full.Node Input))
+arguments = foldM go HashMap.empty
+  where
+    go accumulator (Full.Argument name' valueNode argumentLocation) = do
+        let replaceLocation = flip Full.Node argumentLocation . Full.node
+        argumentValue <- fmap replaceLocation <$> node valueNode
+        pure $ insertIfGiven name' argumentValue accumulator
+
+directive :: Monad m => Full.Directive -> TransformT m Definition.Directive
+directive (Full.Directive name' arguments' _)
+    = Definition.Directive name'
+    . Type.Arguments
+    <$> foldM go HashMap.empty arguments'
+  where
+    go accumulator (Full.Argument argumentName Full.Node{ node = node' } _) = do
+        transformedValue <- directiveValue node'
+        pure $ HashMap.insert argumentName transformedValue accumulator
+
+directiveValue :: Monad m => Full.Value -> TransformT m Type.Value
+directiveValue = \case
+    (Full.Variable name') -> asks
+        $ HashMap.lookupDefault Type.Null name'
+        . variableValues
+    (Full.Int integer) -> pure $ Type.Int integer
+    (Full.Float double) -> pure $ Type.Float double
+    (Full.String string) -> pure $ Type.String string
+    (Full.Boolean boolean) -> pure $ Type.Boolean boolean
+    Full.Null -> pure Type.Null
+    (Full.Enum enum) -> pure $ Type.Enum enum
+    (Full.List list) -> Type.List <$> traverse directiveNode list
+    (Full.Object objectFields) ->
+        Type.Object <$> foldM objectField HashMap.empty objectFields
+  where
+    directiveNode Full.Node{ node = node'} = directiveValue node'
+    objectField accumulator Full.ObjectField{ name, value } = do
+        transformedValue <- directiveNode value
+        pure $ HashMap.insert name transformedValue accumulator
+
+input :: Monad m => Full.Value -> TransformT m (Maybe Input)
+input (Full.Variable name') =
+    asks (HashMap.lookup name' . variableValues) <&> fmap Variable
+input (Full.Int integer) = pure $ Just $ Int integer
+input (Full.Float double) = pure $ Just $ Float double
+input (Full.String string) = pure $ Just $ String string
+input (Full.Boolean boolean) = pure $ Just $ Boolean boolean
+input Full.Null = pure $ Just Null
+input (Full.Enum enum) = pure $ Just $ Enum enum
+input (Full.List list) = Just . List
+    <$> traverse (fmap (fromMaybe Null) . input . Full.node) list
+input (Full.Object objectFields) = Just . Object
+    <$> foldM objectField HashMap.empty objectFields
+  where
+    objectField accumulator Full.ObjectField{..} = do
+        objectFieldValue <- fmap Full.node <$> node value
+        pure $ insertIfGiven name objectFieldValue accumulator
+
+insertIfGiven :: forall a
+    . Full.Name
+    -> Maybe a
     -> HashMap Full.Name a
-    -> Full.Document
+    -> HashMap Full.Name a
-    -> Either QueryError (Document m)
+insertIfGiven name (Just v) = HashMap.insert name v
-document schema operationName subs ast = do
+insertIfGiven _ _ = id
-    let referencedTypes = Schema.types schema
 
-    (operations, fragmentTable) <- defragment ast
+node :: Monad m => Full.Node Full.Value -> TransformT m (Maybe (Full.Node Input))
-    chosenOperation <- getOperation operationName operations
+node Full.Node{node = node', ..} =
-    coercedValues <- coerceVariableValues referencedTypes chosenOperation subs
+    traverse Full.Node <$> input node' <*> pure location
 
-    let replacement = Replacement
-            { fragments = HashMap.empty
-            , fragmentDefinitions = fragmentTable
-            , variableValues = coercedValues
-            , types = referencedTypes
-            }
-    case chosenOperation of
-        OperationDefinition Full.Query _ _ _ _ ->
-            pure $ Document referencedTypes (Schema.query schema)
-                $ operation chosenOperation replacement
-        OperationDefinition Full.Mutation _ _ _ _
-            | Just mutationType <- Schema.mutation schema ->
-                pure $ Document referencedTypes mutationType
-                    $ operation chosenOperation replacement
-        OperationDefinition Full.Subscription _ _ _ _
-            | Just subscriptionType <- Schema.subscription schema ->
-                pure $ Document referencedTypes subscriptionType
-                    $ operation chosenOperation replacement
-        _ -> Left UnsupportedRootOperation
-
-defragment
-    :: Full.Document
-    -> Either QueryError (NonEmpty OperationDefinition, FragmentDefinitions)
-defragment ast =
-    let (operations, fragmentTable) = foldr defragment' ([], HashMap.empty) ast
-        nonEmptyOperations = NonEmpty.nonEmpty operations
-        emptyDocument = Left EmptyDocument
-     in (, fragmentTable) <$> maybe emptyDocument Right nonEmptyOperations
-  where
-    defragment' definition (operations, fragments')
-        | (Full.ExecutableDefinition executable) <- definition
-        , (Full.DefinitionOperation operation') <- executable =
-            (transform operation' : operations, fragments')
-        | (Full.ExecutableDefinition executable) <- definition
-        , (Full.DefinitionFragment fragment) <- executable
-        , (Full.FragmentDefinition name _ _ _ _) <- fragment =
-            (operations, HashMap.insert name fragment fragments')
-    defragment' _ acc = acc
-    transform = \case
-        Full.OperationDefinition type' name variables directives' selections _ ->
-            OperationDefinition type' name variables directives' selections
-        Full.SelectionSet selectionSet _ ->
-            OperationDefinition Full.Query Nothing mempty mempty selectionSet
-
--- * Operation
-
-operation :: OperationDefinition -> Replacement m -> Operation m
-operation operationDefinition replacement
-    = runIdentity
-    $ evalStateT (collectFragments >> transform operationDefinition) replacement
-  where
-    transform (OperationDefinition Full.Query name _ _ sels) =
-        Query name <$> appendSelection sels
-    transform (OperationDefinition Full.Mutation name _ _ sels) =
-        Mutation name <$> appendSelection sels
-    transform (OperationDefinition Full.Subscription name _ _ sels) =
-        Subscription name <$> appendSelection sels
-
--- * Selection
-
-selection
-    :: Full.Selection
-    ->  State (Replacement m) (Either (Seq (Selection m)) (Selection m))
-selection (Full.FieldSelection fieldSelection) =
-    maybe (Left mempty) (Right . SelectionField) <$> field fieldSelection
-selection (Full.FragmentSpreadSelection fragmentSelection)
-    = maybe (Left mempty) (Right . SelectionFragment)
-    <$> fragmentSpread fragmentSelection
-selection (Full.InlineFragmentSelection fragmentSelection) =
-    inlineFragment fragmentSelection
-
-field :: Full.Field ->  State (Replacement m) (Maybe (Field m))
-field (Full.Field alias name arguments' directives' selections _) = do
-    fieldArguments <- foldM go HashMap.empty arguments'
-    fieldSelections <- appendSelection selections
-    fieldDirectives <- Definition.selection <$> directives directives'
-    let field' = Field alias name fieldArguments fieldSelections
-    pure $ field' <$ fieldDirectives
-  where
-    go arguments (Full.Argument name' (Full.Node value' _) _) =
-        inputField arguments name' value'
-
-fragmentSpread
-    :: Full.FragmentSpread
-    -> State (Replacement m) (Maybe (Fragment m))
-fragmentSpread (Full.FragmentSpread name directives' _) = do
-    spreadDirectives <- Definition.selection <$> directives directives'
-    fragments' <- gets fragments
-
-    fragmentDefinitions' <- gets fragmentDefinitions
-    case HashMap.lookup name fragments' of
-        Just definition -> lift $ pure $ definition <$ spreadDirectives
-        Nothing
-            | Just definition <- HashMap.lookup name fragmentDefinitions' -> do
-                fragDef <- fragmentDefinition definition
-                case fragDef of
-                    Just fragment -> lift $ pure $ fragment <$ spreadDirectives
-                    _ -> lift $ pure  Nothing
-            | otherwise -> lift $ pure  Nothing
-
-inlineFragment
-    :: Full.InlineFragment
-    ->  State (Replacement m) (Either (Seq (Selection m)) (Selection m))
-inlineFragment (Full.InlineFragment type' directives' selections _) = do
-    fragmentDirectives <- Definition.selection <$> directives directives'
-    case fragmentDirectives of
-        Nothing -> pure $ Left mempty
-        _ -> do
-            fragmentSelectionSet <- appendSelection selections
-
-            case type' of
-                Nothing -> pure $ Left fragmentSelectionSet
-                Just typeName -> do
-                    types' <- gets types
-                    case Type.lookupTypeCondition typeName types' of
-                        Just typeCondition -> pure $
-                            selectionFragment typeCondition fragmentSelectionSet
-                        Nothing -> pure $ Left mempty
-  where
-    selectionFragment typeName = Right
-        . SelectionFragment
-        . Fragment typeName
-
-appendSelection :: Traversable t
-    => t Full.Selection
-    ->  State (Replacement m) (Seq (Selection m))
-appendSelection = foldM go mempty
-  where
-    go acc sel = append acc <$> selection sel
-    append acc (Left list) = list >< acc
-    append acc (Right one) = one <| acc
-
-directives :: [Full.Directive] ->  State (Replacement m) [Definition.Directive]
-directives = traverse directive
-  where
-    directive (Full.Directive directiveName directiveArguments _)
-        = Definition.Directive directiveName . Type.Arguments
-        <$> foldM go HashMap.empty directiveArguments
-    go arguments (Full.Argument name (Full.Node value' _) _) = do
-        substitutedValue <- value value'
-        return $ HashMap.insert name substitutedValue arguments
-
--- * Fragment replacement
-
--- | Extract fragment definitions into a single 'HashMap'.
-collectFragments ::  State (Replacement m) ()
-collectFragments = do
-    fragDefs <- gets fragmentDefinitions
-    let nextValue = head $ HashMap.elems fragDefs
-    unless (HashMap.null fragDefs) $ do
-        _ <- fragmentDefinition nextValue
-        collectFragments
-
-fragmentDefinition
-    :: Full.FragmentDefinition
-    ->  State (Replacement m) (Maybe (Fragment m))
-fragmentDefinition (Full.FragmentDefinition name type' _ selections _) = do
-    modify deleteFragmentDefinition
-    fragmentSelection <- appendSelection selections
-    types' <- gets types
-
-    case Type.lookupTypeCondition type' types' of
-        Just compositeType -> do
-            let newValue = Fragment compositeType fragmentSelection
-            modify $ insertFragment newValue
-            lift $ pure $ Just newValue
-        _ -> lift $ pure Nothing
-  where
-    deleteFragmentDefinition replacement@Replacement{..} =
-        let newDefinitions = HashMap.delete name fragmentDefinitions
-         in replacement{ fragmentDefinitions = newDefinitions }
-    insertFragment newValue replacement@Replacement{..} =
-        let newFragments = HashMap.insert name newValue fragments
-         in replacement{ fragments = newFragments }
-
-value :: forall m. Full.Value -> State (Replacement m) Type.Value
-value (Full.Variable name) =
-    gets (fromMaybe Type.Null . HashMap.lookup name . variableValues)
-value (Full.Int int) = pure $ Type.Int int
-value (Full.Float float) = pure $ Type.Float float
-value (Full.String string) = pure $ Type.String string
-value (Full.Boolean boolean) = pure $ Type.Boolean boolean
-value Full.Null = pure Type.Null
-value (Full.Enum enum) = pure $ Type.Enum enum
-value (Full.List list) = Type.List <$> traverse value list
-value (Full.Object object) =
-    Type.Object . HashMap.fromList <$> traverse objectField object
-  where
-    objectField Full.ObjectField{value = value', ..} =
-        (name,) <$> value (Full.node value')
-
-input :: forall m. Full.Value -> State (Replacement m) (Maybe Input)
-input (Full.Variable name) =
-    gets (fmap Variable . HashMap.lookup name . variableValues)
-input (Full.Int int) = pure $ pure $ Int int
-input (Full.Float float) = pure $ pure $ Float float
-input (Full.String string) = pure $ pure $ String string
-input (Full.Boolean boolean) = pure $ pure $ Boolean boolean
-input Full.Null = pure $ pure Null
-input (Full.Enum enum) = pure $ pure $ Enum enum
-input (Full.List list) = pure . List <$> traverse value list
-input (Full.Object object) = do
-    objectFields <- foldM objectField HashMap.empty object
-    pure $ pure $ Object objectFields
-  where
-    objectField resultMap Full.ObjectField{value = value', ..} =
-        inputField resultMap name $ Full.node value'
-
-inputField :: forall m
-    . HashMap Full.Name Input
-    -> Full.Name
-    -> Full.Value
-    -> State (Replacement m) (HashMap Full.Name Input)
-inputField resultMap name value' = do
-    objectFieldValue <-  input value'
-    case objectFieldValue of
-        Just fieldValue -> pure $ HashMap.insert name fieldValue resultMap
-        Nothing -> pure resultMap

src/Language/GraphQL/TH.hs

@@ -0,0 +1,38 @@
+{- This Source Code Form is subject to the terms of the Mozilla Public License,
+   v. 2.0. If a copy of the MPL was not distributed with this file, You can
+   obtain one at https://mozilla.org/MPL/2.0/. -}
+
+-- | Template Haskell helpers.
+module Language.GraphQL.TH
+    ( gql
+    ) where
+
+import Language.Haskell.TH.Quote (QuasiQuoter(..))
+import Language.Haskell.TH (Exp(..), Lit(..))
+
+stripIndentation :: String -> String
+stripIndentation code = reverse
+    $ dropNewlines
+    $ reverse
+    $ unlines
+    $ indent spaces <$> lines withoutLeadingNewlines
+  where
+    indent 0 xs = xs
+    indent count (' ' : xs) = indent (count - 1) xs
+    indent _ xs = xs
+    withoutLeadingNewlines = dropNewlines code
+    dropNewlines = dropWhile (== '\n')
+    spaces = length $ takeWhile (== ' ') withoutLeadingNewlines
+
+-- | Removes leading and trailing newlines. Indentation of the first line is
+-- removed from each line of the string.
+gql :: QuasiQuoter
+gql = QuasiQuoter
+    { quoteExp = pure . LitE . StringL . stripIndentation
+    , quotePat = const
+        $ fail "Illegal gql QuasiQuote (allowed as expression only, used as a pattern)"
+    , quoteType = const
+        $ fail "Illegal gql QuasiQuote (allowed as expression only, used as a type)"
+    , quoteDec = const
+        $ fail "Illegal gql QuasiQuote (allowed as expression only, used as a declaration)"
+    }

src/Language/GraphQL/Type.hs

@@ -21,6 +21,6 @@ module Language.GraphQL.Type
     ) where
 
 import Language.GraphQL.Type.Definition
-import Language.GraphQL.Type.Schema (Schema, schema)
+import Language.GraphQL.Type.Schema (Schema, schema, schemaWithTypes)
 import qualified Language.GraphQL.Type.In as In
 import qualified Language.GraphQL.Type.Out as Out

src/Language/GraphQL/Type/Definition.hs

@@ -1,4 +1,9 @@
+{- This Source Code Form is subject to the terms of the Mozilla Public License,
+   v. 2.0. If a copy of the MPL was not distributed with this file, You can
+   obtain one at https://mozilla.org/MPL/2.0/. -}
+
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE Safe #-}
 
 -- | Types that can be used as both input and output types.
 module Language.GraphQL.Type.Definition
@@ -20,9 +25,12 @@ module Language.GraphQL.Type.Definition
 import Data.Int (Int32)
 import Data.HashMap.Strict (HashMap)
 import qualified Data.HashMap.Strict as HashMap
+import Data.List (intercalate)
 import Data.String (IsString(..))
 import Data.Text (Text)
-import Language.GraphQL.AST (Name)
+import qualified Data.Text as Text
+import Language.GraphQL.AST (Name, escape)
+import Numeric (showFloat)
 import Prelude hiding (id)
 
 -- | Represents accordingly typed GraphQL values.
@@ -35,7 +43,27 @@ data Value
     | Enum Name
     | List [Value] -- ^ Arbitrary nested list.
     | Object (HashMap Name Value)
-    deriving (Eq, Show)
+    deriving Eq
+
+instance Show Value where
+    showList = mappend . showList'
+      where
+        showList' list = "[" ++ intercalate ", " (show <$> list) ++ "]"
+    show (Int integer) = show integer
+    show (Float float') = showFloat float' mempty
+    show (String text) = "\"" <> Text.foldr (mappend . escape) "\"" text
+    show (Boolean boolean') = show boolean'
+    show Null = "null"
+    show (Enum name) = Text.unpack name
+    show (List list) = show list
+    show (Object fields) = unwords
+        [ "{"
+        , intercalate ", " (HashMap.foldrWithKey showObject [] fields)
+        , "}"
+        ]
+      where
+        showObject key value accumulator =
+            concat [Text.unpack key, ": ", show value] : accumulator
 
 instance IsString Value where
     fromString = String . fromString
@@ -63,6 +91,9 @@ data ScalarType = ScalarType Name (Maybe Text)
 instance Eq ScalarType where
     (ScalarType this _) == (ScalarType that _) = this == that
 
+instance Show ScalarType where
+    show (ScalarType typeName _) = Text.unpack typeName
+
 -- | Enum type definition.
 --
 -- Some leaf values of requests and input values are Enums. GraphQL serializes
@@ -73,6 +104,9 @@ data EnumType = EnumType Name (Maybe Text) (HashMap Name EnumValue)
 instance Eq EnumType where
     (EnumType this _ _) == (EnumType that _ _) = this == that
 
+instance Show EnumType where
+    show (EnumType typeName _ _) = Text.unpack typeName
+
 -- | Enum value is a single member of an 'EnumType'.
 newtype EnumValue = EnumValue (Maybe Text)
 

src/Language/GraphQL/Type/In.hs

@@ -3,6 +3,7 @@
    obtain one at https://mozilla.org/MPL/2.0/. -}
 
 {-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE Safe #-}
 {-# LANGUAGE ViewPatterns #-}
 
 -- | Input types and values.
@@ -24,6 +25,7 @@ module Language.GraphQL.Type.In
 
 import Data.HashMap.Strict (HashMap)
 import Data.Text (Text)
+import qualified Data.Text as Text
 import Language.GraphQL.AST.Document (Name)
 import qualified Language.GraphQL.Type.Definition as Definition
 
@@ -40,6 +42,9 @@ data InputObjectType = InputObjectType
 instance Eq InputObjectType where
     (InputObjectType this _ _) == (InputObjectType that _ _) = this == that
 
+instance Show InputObjectType where
+    show (InputObjectType typeName _ _) = Text.unpack typeName
+
 -- | These types may be used as input types for arguments and directives.
 --
 -- GraphQL distinguishes between "wrapping" and "named" types. Each wrapping
@@ -56,6 +61,16 @@ data Type
     | NonNullListType Type
     deriving Eq
 
+instance Show Type where
+    show (NamedScalarType scalarType) = show scalarType
+    show (NamedEnumType enumType) = show enumType
+    show (NamedInputObjectType inputObjectType) = show inputObjectType
+    show (ListType baseType) = concat ["[", show baseType, "]"]
+    show (NonNullScalarType scalarType) = '!' : show scalarType
+    show (NonNullEnumType enumType) = '!' : show enumType
+    show (NonNullInputObjectType inputObjectType) = '!' : show inputObjectType
+    show (NonNullListType baseType) = concat ["![", show baseType, "]"]
+
 -- | Field argument definition.
 data Argument = Argument (Maybe Text) Type (Maybe Definition.Value)
 

src/Language/GraphQL/Type/Internal.hs

@@ -12,13 +12,17 @@ module Language.GraphQL.Type.Internal
     , Directives
     , Schema(..)
     , Type(..)
+    , description
     , directives
     , doesFragmentTypeApply
+    , implementations
     , instanceOf
+    , lookupCompositeField
     , lookupInputType
     , lookupTypeCondition
     , lookupTypeField
     , mutation
+    , outToComposite
     , subscription
     , query
     , types
@@ -52,36 +56,43 @@ type Directives = HashMap Full.Name Directive
 -- | A Schema is created by supplying the root types of each type of operation,
 --   query and mutation (optional). A schema definition is then supplied to the
 --   validator and executor.
---
---   __Note:__ When the schema is constructed, by default only the types that
---   are reachable by traversing the root types are included, other types must
---   be explicitly referenced.
 data Schema m = Schema
-    (Out.ObjectType m)
+    (Maybe Text) -- ^ Description.
-    (Maybe (Out.ObjectType m))
+    (Out.ObjectType m) -- ^ Query.
-    (Maybe (Out.ObjectType m))
+    (Maybe (Out.ObjectType m)) -- ^ Mutation.
-    Directives
+    (Maybe (Out.ObjectType m)) -- ^ Subscription.
-    (HashMap Full.Name (Type m))
+    Directives -- ^ Directives
+    (HashMap Full.Name (Type m)) -- ^ Types.
+    -- Interface implementations (used only for faster access).
+    (HashMap Full.Name [Type m])
+
+-- | Schema description.
+description :: forall m. Schema m -> Maybe Text
+description (Schema description' _ _ _ _ _ _) = description'
 
 -- | Schema query type.
 query :: forall m. Schema m -> Out.ObjectType m
-query (Schema query' _ _ _ _) = query'
+query (Schema _ query' _ _ _ _ _) = query'
 
 -- | Schema mutation type.
 mutation :: forall m. Schema m -> Maybe (Out.ObjectType m)
-mutation (Schema _ mutation' _ _ _) = mutation'
+mutation (Schema _ _ mutation' _ _ _ _) = mutation'
 
 -- | Schema subscription type.
 subscription :: forall m. Schema m -> Maybe (Out.ObjectType m)
-subscription (Schema _ _ subscription' _ _) = subscription'
+subscription (Schema _ _ _ subscription' _ _ _) = subscription'
 
 -- | Schema directive definitions.
 directives :: forall m. Schema m -> Directives
-directives (Schema _ _ _ directives' _) = directives'
+directives (Schema _ _ _ _ directives' _ _) = directives'
 
 -- | Types referenced by the schema.
 types :: forall m. Schema m -> HashMap Full.Name (Type m)
-types (Schema _ _ _ _ types') = types'
+types (Schema _ _ _ _ _ types' _) = types'
+
+-- | Interface implementations.
+implementations :: forall m. Schema m -> HashMap Full.Name [Type m]
+implementations (Schema _ _ _ _ _ _ implementations') = implementations'
 
 -- | These types may describe the parent context of a selection set.
 data CompositeType m
@@ -160,12 +171,16 @@ lookupInputType (Full.TypeNonNull (Full.NonNullTypeList nonNull)) types'
     <$> lookupInputType nonNull types'
 
 lookupTypeField :: forall a. Full.Name -> Out.Type a -> Maybe (Out.Field a)
-lookupTypeField fieldName = \case
+lookupTypeField fieldName outputType =
-    Out.ObjectBaseType objectType ->
+    outToComposite outputType >>= lookupCompositeField fieldName
-        objectChild objectType
+
-    Out.InterfaceBaseType interfaceType ->
+lookupCompositeField :: forall a
-        interfaceChild interfaceType
+    . Full.Name
-    Out.ListBaseType listType -> lookupTypeField fieldName listType
+    -> CompositeType a
+    -> Maybe (Out.Field a)
+lookupCompositeField fieldName = \case
+    CompositeObjectType objectType -> objectChild objectType
+    CompositeInterfaceType interfaceType -> interfaceChild interfaceType
     _ -> Nothing
   where
     objectChild (Out.ObjectType _ _ _ resolvers) =
@@ -174,3 +189,12 @@ lookupTypeField fieldName = \case
         HashMap.lookup fieldName fields
     resolverType (Out.ValueResolver objectField _) = objectField
     resolverType (Out.EventStreamResolver objectField _ _) = objectField
+
+outToComposite :: forall a. Out.Type a -> Maybe (CompositeType a)
+outToComposite = \case
+    Out.ObjectBaseType objectType -> Just $ CompositeObjectType objectType
+    Out.InterfaceBaseType interfaceType ->
+        Just $ CompositeInterfaceType interfaceType
+    Out.UnionBaseType unionType -> Just $ CompositeUnionType unionType
+    Out.ListBaseType listType -> outToComposite listType
+    _ -> Nothing

src/Language/GraphQL/Type/Out.hs

@@ -38,6 +38,7 @@ import Data.HashMap.Strict (HashMap)
 import qualified Data.HashMap.Strict as HashMap
 import Data.Maybe (fromMaybe)
 import Data.Text (Text)
+import qualified Data.Text as Text
 import Language.GraphQL.AST (Name)
 import Language.GraphQL.Type.Definition
 import qualified Language.GraphQL.Type.In as In
@@ -52,6 +53,9 @@ data ObjectType m = ObjectType
 instance forall a. Eq (ObjectType a) where
     (ObjectType this _ _ _) == (ObjectType that _ _ _) = this == that
 
+instance forall a. Show (ObjectType a) where
+    show (ObjectType typeName _ _ _) = Text.unpack typeName
+
 -- | Interface Type Definition.
 --
 -- When a field can return one of a heterogeneous set of types, a Interface type
@@ -63,6 +67,9 @@ data InterfaceType m = InterfaceType
 instance forall a. Eq (InterfaceType a) where
     (InterfaceType this _ _ _) == (InterfaceType that _ _ _) = this == that
 
+instance forall a. Show (InterfaceType a) where
+    show (InterfaceType typeName _ _ _) = Text.unpack typeName
+
 -- | Union Type Definition.
 --
 -- When a field can return one of a heterogeneous set of types, a Union type is
@@ -72,6 +79,9 @@ data UnionType m = UnionType Name (Maybe Text) [ObjectType m]
 instance forall a. Eq (UnionType a) where
     (UnionType this _ _) == (UnionType that _ _) = this == that
 
+instance forall a. Show (UnionType a) where
+    show (UnionType typeName _ _) = Text.unpack typeName
+
 -- | Output object field definition.
 data Field m = Field
     (Maybe Text) -- ^ Description.
@@ -98,6 +108,20 @@ data Type m
     | NonNullListType (Type m)
     deriving Eq
 
+instance forall a. Show (Type a) where
+    show (NamedScalarType scalarType) = show scalarType
+    show (NamedEnumType enumType) = show enumType
+    show (NamedObjectType inputObjectType) = show inputObjectType
+    show (NamedInterfaceType interfaceType) = show interfaceType
+    show (NamedUnionType unionType) = show unionType
+    show (ListType baseType) = concat ["[", show baseType, "]"]
+    show (NonNullScalarType scalarType) = '!' : show scalarType
+    show (NonNullEnumType enumType) = '!' : show enumType
+    show (NonNullObjectType inputObjectType) = '!' : show inputObjectType
+    show (NonNullInterfaceType interfaceType) = '!' : show interfaceType
+    show (NonNullUnionType unionType) = '!' : show unionType
+    show (NonNullListType baseType) = concat ["![", show baseType, "]"]
+
 -- | Matches either 'NamedScalarType' or 'NonNullScalarType'.
 pattern ScalarBaseType :: forall m. ScalarType -> Type m
 pattern ScalarBaseType scalarType <- (isScalarType -> Just scalarType)

src/Language/GraphQL/Type/Schema.hs

@@ -9,11 +9,13 @@
 -- functions for defining and manipulating schemas.
 module Language.GraphQL.Type.Schema
     ( schema
+    , schemaWithTypes
     , module Language.GraphQL.Type.Internal
     ) where
 
 import Data.HashMap.Strict (HashMap)
 import qualified Data.HashMap.Strict as HashMap
+import Data.Text (Text)
 import Language.GraphQL.AST.DirectiveLocation (DirectiveLocation(..))
 import qualified Language.GraphQL.AST.DirectiveLocation as DirectiveLocation
 import qualified Language.GraphQL.AST as Full
@@ -22,7 +24,9 @@ import Language.GraphQL.Type.Internal
     , Directives
     , Schema
     , Type(..)
+    , description
     , directives
+    , implementations
     , mutation
     , subscription
     , query
@@ -34,16 +38,48 @@ import qualified Language.GraphQL.Type.In as In
 import qualified Language.GraphQL.Type.Out as Out
 
 -- | Schema constructor.
+--
+-- __Note:__ When the schema is constructed, by default only the types that
+-- are reachable by traversing the root types are included, other types must
+-- be explicitly referenced using 'schemaWithTypes' instead.
 schema :: forall m
     . Out.ObjectType m -- ^ Query type.
     -> Maybe (Out.ObjectType m) -- ^ Mutation type.
     -> Maybe (Out.ObjectType m) -- ^ Subscription type.
     -> Directives -- ^ Directive definitions.
     -> Schema m -- ^ Schema.
-schema queryRoot mutationRoot subscriptionRoot directiveDefinitions =
+schema queryRoot mutationRoot subscriptionRoot =
-    Internal.Schema queryRoot mutationRoot subscriptionRoot allDirectives collectedTypes
+    schemaWithTypes Nothing queryRoot mutationRoot subscriptionRoot mempty
+
+-- | Constructs a complete schema, including user-defined types not referenced
+-- in the schema directly (for example interface implementations).
+schemaWithTypes :: forall m
+    . Maybe Text -- ^ Schema description
+    -> Out.ObjectType m -- ^ Query type.
+    -> Maybe (Out.ObjectType m) -- ^ Mutation type.
+    -> Maybe (Out.ObjectType m) -- ^ Subscription type.
+    -> [Type m] -- ^ Additional types.
+    -> Directives -- ^ Directive definitions.
+    -> Schema m -- ^ Schema.
+schemaWithTypes description' queryRoot mutationRoot subscriptionRoot types' directiveDefinitions =
+    Internal.Schema description' queryRoot mutationRoot subscriptionRoot
+        allDirectives collectedTypes collectedImplementations
   where
-    collectedTypes = collectReferencedTypes queryRoot mutationRoot subscriptionRoot
+    allTypes = foldr addTypeDefinition HashMap.empty types'
+    addTypeDefinition type'@(ScalarType (Definition.ScalarType typeName _)) accumulator =
+        HashMap.insert typeName type' accumulator
+    addTypeDefinition type'@(EnumType (Definition.EnumType typeName _ _)) accumulator =
+        HashMap.insert typeName type' accumulator
+    addTypeDefinition type'@(ObjectType (Out.ObjectType typeName _ _ _)) accumulator =
+        HashMap.insert typeName type' accumulator
+    addTypeDefinition type'@(InputObjectType (In.InputObjectType typeName _ _)) accumulator =
+        HashMap.insert typeName type' accumulator
+    addTypeDefinition type'@(InterfaceType (Out.InterfaceType typeName _ _ _)) accumulator =
+        HashMap.insert typeName type' accumulator
+    addTypeDefinition type'@(UnionType (Out.UnionType typeName _ _)) accumulator =
+        HashMap.insert typeName type' accumulator
+    collectedTypes = collectReferencedTypes queryRoot mutationRoot subscriptionRoot allTypes
+    collectedImplementations = collectImplementations collectedTypes
     allDirectives = HashMap.union directiveDefinitions defaultDirectives
     defaultDirectives = HashMap.fromList
         [ ("skip", skipDirective)
@@ -95,11 +131,12 @@ collectReferencedTypes :: forall m
     -> Maybe (Out.ObjectType m)
     -> Maybe (Out.ObjectType m)
     -> HashMap Full.Name (Type m)
-collectReferencedTypes queryRoot mutationRoot subscriptionRoot =
+    -> HashMap Full.Name (Type m)
-    let queryTypes = traverseObjectType queryRoot HashMap.empty
+collectReferencedTypes queryRoot mutationRoot subscriptionRoot extraTypes =
+    let queryTypes = traverseObjectType queryRoot extraTypes
         mutationTypes = maybe queryTypes (`traverseObjectType` queryTypes)
             mutationRoot
-     in maybe mutationTypes (`traverseObjectType` queryTypes) subscriptionRoot
+     in maybe mutationTypes (`traverseObjectType` mutationTypes) subscriptionRoot
   where
     collect traverser typeName element foundTypes
         | HashMap.member typeName foundTypes = foundTypes
@@ -153,3 +190,20 @@ collectReferencedTypes queryRoot mutationRoot subscriptionRoot =
     polymorphicTraverser interfaces fields
         = flip (foldr visitFields) fields
         . flip (foldr traverseInterfaceType) interfaces
+
+-- | Looks for objects and interfaces under the schema types and collects the
+-- interfaces they implement.
+collectImplementations :: forall m
+    . HashMap Full.Name (Type m)
+    -> HashMap Full.Name [Type m]
+collectImplementations = HashMap.foldr go HashMap.empty
+  where
+    go implementation@(InterfaceType interfaceType) accumulator =
+        let Out.InterfaceType _ _ interfaces _ = interfaceType
+         in foldr (add implementation) accumulator interfaces
+    go implementation@(ObjectType objectType) accumulator =
+        let Out.ObjectType _ _ interfaces _ = objectType
+         in foldr (add implementation) accumulator interfaces
+    go _ accumulator = accumulator
+    add implementation (Out.InterfaceType typeName _ _ _) accumulator =
+        HashMap.insertWith (++) typeName [implementation] accumulator

src/Language/GraphQL/Validate.hs

@@ -4,7 +4,6 @@
 
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE RecordWildCards #-}
-{-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 
 -- | GraphQL validator.
@@ -210,7 +209,7 @@ typeDefinition context rule = \case
         directives context rule scalarLocation directives'
     Full.ObjectTypeDefinition _ _ _ directives' fields
         -> directives context rule objectLocation directives'
-         >< foldMap (fieldDefinition context rule) fields
+        >< foldMap (fieldDefinition context rule) fields
     Full.InterfaceTypeDefinition _ _ directives' fields
         -> directives context rule interfaceLocation directives'
         >< foldMap (fieldDefinition context rule) fields
@@ -315,9 +314,6 @@ constValue (Validation.ValueRule _ rule) valueType = go valueType
     go inputObjectType value'@(Full.Node (Full.ConstObject fields) _)
         = foldMap (forEach inputObjectType) (Seq.fromList fields)
         |> rule inputObjectType value'
-    go listType value'@(Full.Node (Full.ConstList values) location')
-        = embedListLocation go listType values location'
-        |> rule listType value'
     go anotherValue value' = pure $ rule anotherValue value'
     forEach inputObjectType Full.ObjectField{value = value', ..} =
         go (valueTypeByName name inputObjectType) value'
@@ -421,20 +417,6 @@ argument rule argumentType (Full.Argument _ value' _) =
   where
     valueType (In.Argument _ valueType' _) = valueType'
 
--- valueTypeFromList :: Maybe In.Type -> Maybe In.Type
-embedListLocation :: forall a m
-    . (Maybe In.Type -> Full.Node a -> Seq m)
-    -> Maybe In.Type
-    -> [a]
-    -> Full.Location
-    -> Seq m
-embedListLocation go listType values location'
-    = foldMap (go $ valueTypeFromList listType) 
-    $ flip Full.Node location' <$> Seq.fromList values
-  where
-    valueTypeFromList (Just (In.ListBaseType baseType)) = Just baseType
-    valueTypeFromList _ = Nothing
-
 value :: forall m
     . Validation.Rule m
     -> Maybe In.Type
@@ -445,9 +427,6 @@ value (Validation.ValueRule rule _) valueType = go valueType
     go inputObjectType value'@(Full.Node (Full.Object fields) _)
         = foldMap (forEach inputObjectType) (Seq.fromList fields)
         |> rule inputObjectType value'
-    go listType value'@(Full.Node (Full.List values) location')
-        = embedListLocation go listType values location'
-        |> rule listType value'
     go anotherValue value' = pure $ rule anotherValue value'
     forEach inputObjectType Full.ObjectField{value = value', ..} =
         go (valueTypeByName name inputObjectType) value'

src/Language/GraphQL/Validate/Rules.hs

@@ -3,6 +3,7 @@
    obtain one at https://mozilla.org/MPL/2.0/. -}
 
 {-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -24,6 +25,8 @@ module Language.GraphQL.Validate.Rules
     , noUndefinedVariablesRule
     , noUnusedFragmentsRule
     , noUnusedVariablesRule
+    , overlappingFieldsCanBeMergedRule
+    , possibleFragmentSpreadsRule
     , providedRequiredInputFieldsRule
     , providedRequiredArgumentsRule
     , scalarLeafsRule
@@ -35,22 +38,24 @@ module Language.GraphQL.Validate.Rules
     , uniqueInputFieldNamesRule
     , uniqueOperationNamesRule
     , uniqueVariableNamesRule
+    , valuesOfCorrectTypeRule
+    , variablesInAllowedPositionRule
     , variablesAreInputTypesRule
     ) where
 
 import Control.Monad ((>=>), foldM)
 import Control.Monad.Trans.Class (MonadTrans(..))
-import Control.Monad.Trans.Reader (ReaderT(..), asks, mapReaderT)
+import Control.Monad.Trans.Reader (ReaderT(..), ask, asks, mapReaderT)
 import Control.Monad.Trans.State (StateT, evalStateT, gets, modify)
 import Data.Bifunctor (first)
-import Data.Foldable (find, toList)
+import Data.Foldable (find, fold, foldl', toList)
 import qualified Data.HashMap.Strict as HashMap
 import Data.HashMap.Strict (HashMap)
 import Data.HashSet (HashSet)
 import qualified Data.HashSet as HashSet
 import Data.List (groupBy, sortBy, sortOn)
-import Data.Maybe (isNothing, mapMaybe)
+import Data.Maybe (catMaybes, fromMaybe, isJust, isNothing, mapMaybe)
-import Data.List.NonEmpty (NonEmpty)
+import Data.List.NonEmpty (NonEmpty(..))
 import Data.Ord (comparing)
 import Data.Sequence (Seq(..), (|>))
 import qualified Data.Sequence as Seq
@@ -80,6 +85,7 @@ specifiedRules =
     -- Fields
     , fieldsOnCorrectTypeRule
     , scalarLeafsRule
+    , overlappingFieldsCanBeMergedRule
     -- Arguments.
     , knownArgumentNamesRule
     , uniqueArgumentNamesRule
@@ -91,7 +97,9 @@ specifiedRules =
     , noUnusedFragmentsRule
     , fragmentSpreadTargetDefinedRule
     , noFragmentCyclesRule
+    , possibleFragmentSpreadsRule
     -- Values
+    , valuesOfCorrectTypeRule
     , knownInputFieldNamesRule
     , uniqueInputFieldNamesRule
     , providedRequiredInputFieldsRule
@@ -104,6 +112,7 @@ specifiedRules =
     , variablesAreInputTypesRule
     , noUndefinedVariablesRule
     , noUnusedVariablesRule
+    , variablesInAllowedPositionRule
     ]
 
 -- | Definition must be OperationDefinition or FragmentDefinition.
@@ -320,10 +329,8 @@ fragmentSpreadTypeExistenceRule :: forall m. Rule m
 fragmentSpreadTypeExistenceRule = SelectionRule $ const $ \case
     Full.FragmentSpreadSelection fragmentSelection
         | Full.FragmentSpread fragmentName _ location' <- fragmentSelection -> do
-            ast' <- asks ast
-            let target = find (isSpreadTarget fragmentName) ast'
-            typeCondition <- lift $ maybeToSeq $ target >>= extractTypeCondition
             types' <- asks $ Schema.types . schema
+            typeCondition <- findSpreadTarget fragmentName
             case HashMap.lookup typeCondition types' of
                 Nothing -> pure $ Error
                     { message = spreadError fragmentName typeCondition
@@ -342,10 +349,6 @@ fragmentSpreadTypeExistenceRule = SelectionRule $ const $ \case
                 Just _ -> lift mempty
     _ -> lift mempty
   where
-    extractTypeCondition (viewFragment -> Just fragmentDefinition) =
-        let Full.FragmentDefinition _ typeCondition _ _ _ = fragmentDefinition
-         in Just typeCondition
-    extractTypeCondition _ = Nothing
     spreadError fragmentName typeCondition = concat
         [ "Fragment \""
         , Text.unpack fragmentName
@@ -451,8 +454,7 @@ filterSelections applyFilter selections
 noFragmentCyclesRule :: forall m. Rule m
 noFragmentCyclesRule = FragmentDefinitionRule $ \case
     Full.FragmentDefinition fragmentName _ _ selections location' -> do
-        state <- evalStateT (collectFields selections)
+        state <- evalStateT (collectCycles selections) (0, fragmentName)
-            (0, fragmentName)
         let spreadPath = fst <$> sortBy (comparing snd) (HashMap.toList state)
         case reverse spreadPath of
             x : _ | x == fragmentName -> pure $ Error
@@ -467,10 +469,10 @@ noFragmentCyclesRule = FragmentDefinitionRule $ \case
                 }
             _ -> lift mempty
   where
-    collectFields :: Traversable t
+    collectCycles :: Traversable t
         => t Full.Selection
         -> StateT (Int, Full.Name) (ReaderT (Validation m) Seq) (HashMap Full.Name Int)
-    collectFields selectionSet = foldM forEach HashMap.empty selectionSet
+    collectCycles selectionSet = foldM forEach HashMap.empty selectionSet
     forEach accumulator = \case
         Full.FieldSelection fieldSelection -> forField accumulator fieldSelection
         Full.InlineFragmentSelection fragmentSelection ->
@@ -487,15 +489,15 @@ noFragmentCyclesRule = FragmentDefinitionRule $ \case
             then pure newAccumulator
             else collectFromSpread fragmentName newAccumulator
     forInline accumulator (Full.InlineFragment _ _ selections _) =
-        (accumulator <>) <$> collectFields selections
+        (accumulator <>) <$> collectCycles selections
     forField accumulator (Full.Field _ _ _ _ selections _) =
-        (accumulator <>) <$> collectFields selections
+        (accumulator <>) <$> collectCycles selections
     collectFromSpread fragmentName accumulator = do
         ast' <- lift $ asks ast
         case findFragmentDefinition fragmentName ast' of
             Nothing -> pure accumulator
             Just (Full.FragmentDefinition _ _ _ selections _) ->
-                (accumulator <>) <$> collectFields selections
+                (accumulator <>) <$> collectCycles selections
 
 findFragmentDefinition :: Text
     -> NonEmpty Full.Definition
@@ -531,15 +533,22 @@ uniqueDirectiveNamesRule = DirectivesRule
     extract (Full.Directive directiveName _ location') =
         (directiveName, location')
 
-filterDuplicates :: (a -> (Text, Full.Location)) -> String -> [a] -> Seq Error
+groupSorted :: forall a. (a -> Text) -> [a] -> [[a]]
+groupSorted getName = groupBy equalByName . sortOn getName
+  where
+    equalByName lhs rhs = getName lhs == getName rhs
+
+filterDuplicates :: forall a
+    . (a -> (Text, Full.Location))
+    -> String
+    -> [a]
+    -> Seq Error
 filterDuplicates extract nodeType = Seq.fromList
     . fmap makeError
     . filter ((> 1) . length)
-    . groupBy equalByName
+    . groupSorted getName
-    . sortOn getName
   where
     getName = fst . extract
-    equalByName lhs rhs = getName lhs == getName rhs
     makeError directives' = Error
         { message = makeMessage $ head directives'
         , locations = snd . extract <$> directives'
@@ -647,12 +656,9 @@ variableUsageDifference difference errorMessage = OperationDefinitionRule $ \cas
             lift $ lift $ mapArguments arguments <> mapDirectives directives'
     variableFilter (Full.FragmentSpreadSelection spread)
         | Full.FragmentSpread fragmentName _ _ <- spread = do
-            definitions <- lift $ asks ast
+            nonVisitedFragmentDefinition <- visitFragmentDefinition fragmentName
-            visited <- gets (HashSet.member fragmentName)
+            case nonVisitedFragmentDefinition of
-            modify (HashSet.insert fragmentName)
+                Just fragmentDefinition -> diveIntoSpread fragmentDefinition
-            case find (isSpreadTarget fragmentName) definitions of
-                Just (viewFragment -> Just fragmentDefinition)
-                    | not visited -> diveIntoSpread fragmentDefinition
                 _ -> lift $ lift mempty
     diveIntoSpread (Full.FragmentDefinition _ _ directives' selections _)
         = filterSelections' selections
@@ -710,7 +716,7 @@ fieldsOnCorrectTypeRule = FieldRule fieldRule
     fieldRule parentType (Full.Field _ fieldName _ _ _ location')
         | Just objectType <- parentType
         , Nothing <- Type.lookupTypeField fieldName objectType
-        , Just typeName <- compositeTypeName objectType = pure $ Error
+        , Just typeName <- typeNameIfComposite objectType = pure $ Error
             { message = errorMessage fieldName typeName
             , locations = [location']
             }
@@ -723,20 +729,17 @@ fieldsOnCorrectTypeRule = FieldRule fieldRule
         , "\"."
         ]
 
-compositeTypeName :: forall m. Out.Type m -> Maybe Full.Name
+compositeTypeName :: forall m. Type.CompositeType m -> Full.Name
-compositeTypeName (Out.ObjectBaseType (Out.ObjectType typeName _ _ _)) =
+compositeTypeName (Type.CompositeObjectType (Out.ObjectType typeName _ _ _)) =
-    Just typeName
+    typeName
-compositeTypeName (Out.InterfaceBaseType interfaceType) =
+compositeTypeName (Type.CompositeInterfaceType interfaceType) =
     let Out.InterfaceType typeName _ _ _ = interfaceType
-        in Just typeName
+     in typeName
-compositeTypeName (Out.UnionBaseType (Out.UnionType typeName _ _)) =
+compositeTypeName (Type.CompositeUnionType (Out.UnionType typeName _ _)) =
-    Just typeName
+    typeName
-compositeTypeName (Out.ScalarBaseType _) =
+
-    Nothing
+typeNameIfComposite :: forall m. Out.Type m -> Maybe Full.Name
-compositeTypeName (Out.EnumBaseType _) =
+typeNameIfComposite = fmap compositeTypeName . Type.outToComposite
-    Nothing
-compositeTypeName (Out.ListBaseType wrappedType) =
-    compositeTypeName wrappedType
 
 -- | Field selections on scalars or enums are never allowed, because they are
 -- the leaf nodes of any GraphQL query.
@@ -794,7 +797,7 @@ knownArgumentNamesRule = ArgumentsRule fieldRule directiveRule
   where
     fieldRule (Just objectType) (Full.Field _ fieldName arguments  _ _ _)
         | Just typeField <- Type.lookupTypeField fieldName objectType
-        , Just typeName <- compositeTypeName objectType =
+        , Just typeName <- typeNameIfComposite objectType =
             lift $ foldr (go typeName fieldName typeField) Seq.empty arguments
     fieldRule _ _ = lift mempty
     go typeName fieldName fieldDefinition (Full.Argument argumentName _ location') errors
@@ -1013,3 +1016,605 @@ providedRequiredInputFieldsRule = ValueRule go constGo
         , Text.unpack typeName
         , "\" is required, but it was not provided."
         ]
+
+-- | If multiple field selections with the same response names are encountered
+-- during execution, the field and arguments to execute and the resulting value
+-- should be unambiguous. Therefore any two field selections which might both be
+-- encountered for the same object are only valid if they are equivalent.
+--
+-- For simple hand‐written GraphQL, this rule is obviously a clear developer
+-- error, however nested fragments can make this difficult to detect manually.
+overlappingFieldsCanBeMergedRule :: Rule m
+overlappingFieldsCanBeMergedRule = OperationDefinitionRule $ \case
+    Full.SelectionSet selectionSet _ -> do
+        schema' <- asks schema
+        go (toList selectionSet)
+            $ Type.CompositeObjectType
+            $ Schema.query schema'
+    Full.OperationDefinition operationType _ _ _ selectionSet _ -> do
+        schema' <- asks schema
+        let root = go (toList selectionSet) . Type.CompositeObjectType
+        case operationType of
+            Full.Query -> root $ Schema.query schema'
+            Full.Mutation
+                | Just objectType <- Schema.mutation schema' -> root objectType
+            Full.Subscription
+                | Just objectType <- Schema.mutation schema' -> root objectType
+            _ -> lift mempty
+  where
+    go selectionSet selectionType = do
+        fieldTuples <- evalStateT (collectFields selectionType selectionSet) HashSet.empty
+        fieldsInSetCanMerge fieldTuples
+    fieldsInSetCanMerge :: forall m
+        . HashMap Full.Name (NonEmpty (Full.Field, Type.CompositeType m))
+        -> ReaderT (Validation m) Seq Error
+    fieldsInSetCanMerge fieldTuples = do
+        validation <- ask
+        let (lonely, paired) = flattenPairs fieldTuples
+        let reader = flip runReaderT validation
+        lift $ foldMap (reader . visitLonelyFields) lonely
+            <> foldMap (reader . forEachFieldTuple) paired
+    forEachFieldTuple :: forall m
+        . (FieldInfo m, FieldInfo m)
+        -> ReaderT (Validation m) Seq Error
+    forEachFieldTuple (fieldA, fieldB) =
+        case (parent fieldA, parent fieldB) of
+            (parentA@Type.CompositeObjectType{}, parentB@Type.CompositeObjectType{})
+                | parentA /= parentB -> sameResponseShape fieldA fieldB
+            _ -> mapReaderT (checkEquality (node fieldA) (node fieldB))
+                $ sameResponseShape fieldA fieldB
+    checkEquality fieldA fieldB Seq.Empty
+        | Full.Field _ fieldNameA _ _ _ _ <- fieldA
+        , Full.Field _ fieldNameB _ _ _ _ <- fieldB
+        , fieldNameA /= fieldNameB = pure $ makeError fieldA fieldB
+        | Full.Field _ fieldNameA argumentsA _ _ locationA <- fieldA
+        , Full.Field _ _ argumentsB _ _ locationB <- fieldB
+        , argumentsA /= argumentsB =
+            let message = concat
+                    [ "Fields \""
+                    , Text.unpack fieldNameA
+                    , "\" conflict because they have different arguments. Use "
+                    , "different aliases on the fields to fetch both if this "
+                    , "was intentional."
+                    ]
+             in pure $ Error message [locationB, locationA]
+    checkEquality _ _ previousErrors = previousErrors
+    visitLonelyFields FieldInfo{..} =
+        let Full.Field _ _ _ _ subSelections _ = node
+            compositeFieldType = Type.outToComposite type'
+         in maybe (lift Seq.empty) (go subSelections) compositeFieldType
+    sameResponseShape :: forall m
+        . FieldInfo m
+        -> FieldInfo m
+        -> ReaderT (Validation m) Seq Error
+    sameResponseShape fieldA fieldB =
+        let Full.Field _ _ _ _ selectionsA _ = node fieldA
+            Full.Field _ _ _ _ selectionsB _ = node fieldB
+         in case unwrapTypes (type' fieldA) (type' fieldB) of
+            Left True -> lift mempty
+            Right (compositeA, compositeB) -> do
+                validation <- ask
+                let collectFields' composite = flip runReaderT validation
+                        . flip evalStateT HashSet.empty
+                        . collectFields composite
+                let collectA = collectFields' compositeA selectionsA
+                let collectB = collectFields' compositeB selectionsB
+                fieldsInSetCanMerge
+                    $ foldl' (HashMap.unionWith (<>)) HashMap.empty
+                    $ collectA <> collectB
+            _ -> pure $ makeError (node fieldA) (node fieldB)
+    makeError fieldA fieldB =
+        let Full.Field aliasA fieldNameA _ _ _ locationA = fieldA
+            Full.Field _ fieldNameB _ _ _ locationB = fieldB
+            message = concat
+                [ "Fields \""
+                , Text.unpack (fromMaybe fieldNameA aliasA)
+                , "\" conflict because \""
+                , Text.unpack fieldNameB
+                , "\" and \""
+                , Text.unpack fieldNameA
+                , "\" are different fields. Use different aliases on the fields "
+                , "to fetch both if this was intentional."
+                ]
+             in Error message [locationB, locationA]
+    unwrapTypes typeA@Out.ScalarBaseType{} typeB@Out.ScalarBaseType{} =
+        Left $ typeA == typeB
+    unwrapTypes typeA@Out.EnumBaseType{} typeB@Out.EnumBaseType{} =
+        Left $ typeA == typeB
+    unwrapTypes (Out.ListType listA) (Out.ListType listB) =
+        unwrapTypes listA listB
+    unwrapTypes (Out.NonNullListType listA) (Out.NonNullListType listB) =
+        unwrapTypes listA listB
+    unwrapTypes typeA typeB
+        | Out.isNonNullType typeA == Out.isNonNullType typeB
+        , Just compositeA <- Type.outToComposite typeA
+        , Just compositeB <- Type.outToComposite typeB =
+            Right (compositeA, compositeB)
+        | otherwise = Left False
+    flattenPairs :: forall m
+        . HashMap Full.Name (NonEmpty (Full.Field, Type.CompositeType m))
+        -> (Seq (FieldInfo m), Seq (FieldInfo m, FieldInfo m))
+    flattenPairs xs = HashMap.foldr splitSingleFields (Seq.empty, Seq.empty)
+        $ foldr lookupTypeField [] <$> xs
+    splitSingleFields :: forall m
+        . [FieldInfo m]
+        -> (Seq (FieldInfo m), Seq (FieldInfo m, FieldInfo m))
+        -> (Seq (FieldInfo m), Seq (FieldInfo m, FieldInfo m))
+    splitSingleFields [head'] (fields, pairList) = (fields |> head', pairList)
+    splitSingleFields xs (fields, pairList) = (fields, pairs pairList xs)
+    lookupTypeField (field, parentType) accumulator =
+        let Full.Field _ fieldName _ _ _ _ = field
+         in case Type.lookupCompositeField fieldName parentType of
+            Nothing -> accumulator
+            Just (Out.Field _ typeField _) ->
+                FieldInfo field typeField parentType : accumulator
+    pairs :: forall m
+        . Seq (FieldInfo m, FieldInfo m)
+        -> [FieldInfo m]
+        -> Seq (FieldInfo m, FieldInfo m)
+    pairs accumulator [] = accumulator
+    pairs accumulator (fieldA : fields) =
+        pair fieldA (pairs accumulator fields) fields
+    pair _ accumulator [] = accumulator
+    pair field accumulator (fieldA : fields) =
+        pair field accumulator fields |> (field, fieldA)
+    collectFields objectType = accumulateFields objectType mempty
+    accumulateFields = foldM . forEach
+    forEach parentType accumulator = \case
+        Full.FieldSelection fieldSelection ->
+            forField parentType accumulator fieldSelection
+        Full.FragmentSpreadSelection fragmentSelection ->
+            forSpread accumulator fragmentSelection
+        Full.InlineFragmentSelection fragmentSelection ->
+            forInline parentType accumulator fragmentSelection
+    forField parentType accumulator field@(Full.Field alias fieldName _ _ _ _) =
+        let key = fromMaybe fieldName alias
+            value = (field, parentType) :| []
+         in pure $ HashMap.insertWith (<>) key value accumulator
+    forSpread accumulator (Full.FragmentSpread fragmentName _ _) = do
+        inVisitetFragments <- gets $ HashSet.member fragmentName
+        if inVisitetFragments
+            then pure accumulator
+            else collectFromSpread fragmentName accumulator
+    forInline parentType accumulator = \case
+        Full.InlineFragment maybeType _ selections _
+            | Just typeCondition <- maybeType ->
+                collectFromFragment typeCondition selections accumulator
+            | otherwise -> accumulateFields parentType accumulator $ toList selections
+    collectFromFragment typeCondition selectionSet' accumulator = do
+        types' <- lift $ asks $ Schema.types . schema
+        case Type.lookupTypeCondition typeCondition types' of
+            Nothing -> pure accumulator
+            Just compositeType ->
+                accumulateFields compositeType accumulator $ toList selectionSet'
+    collectFromSpread fragmentName accumulator = do
+        modify $ HashSet.insert fragmentName
+        ast' <- lift $ asks ast
+        case findFragmentDefinition fragmentName ast' of
+            Nothing -> pure accumulator
+            Just (Full.FragmentDefinition _ typeCondition _ selectionSet' _) ->
+                collectFromFragment typeCondition selectionSet' accumulator
+
+data FieldInfo m = FieldInfo
+    { node :: Full.Field
+    , type' :: Out.Type m
+    , parent :: Type.CompositeType m
+    }
+
+-- | Fragments are declared on a type and will only apply when the runtime
+-- object type matches the type condition. They also are spread within the
+-- context of a parent type. A fragment spread is only valid if its type
+-- condition could ever apply within the parent type.
+possibleFragmentSpreadsRule :: forall m. Rule m
+possibleFragmentSpreadsRule = SelectionRule go
+  where
+    go (Just parentType) (Full.InlineFragmentSelection fragmentSelection)
+        | Full.InlineFragment maybeType _ _ location' <- fragmentSelection
+        , Just typeCondition <- maybeType = do
+            (fragmentTypeName, parentTypeName) <-
+                compareTypes typeCondition parentType
+            pure $ Error
+                { message = concat
+                    [ "Fragment cannot be spread here as objects of type \""
+                    , Text.unpack parentTypeName
+                    , "\" can never be of type \""
+                    , Text.unpack fragmentTypeName
+                    , "\"."
+                    ]
+                , locations = [location']
+                }
+    go (Just parentType) (Full.FragmentSpreadSelection fragmentSelection)
+        | Full.FragmentSpread fragmentName _ location' <- fragmentSelection = do
+            typeCondition <- findSpreadTarget fragmentName
+            (fragmentTypeName, parentTypeName) <-
+                compareTypes typeCondition parentType
+            pure $ Error
+                { message = concat
+                    [ "Fragment \""
+                    , Text.unpack fragmentName
+                    , "\" cannot be spread here as objects of type \""
+                    , Text.unpack parentTypeName
+                    , "\" can never be of type \""
+                    , Text.unpack fragmentTypeName
+                    , "\"."
+                    ]
+                , locations = [location']
+                }
+    go _ _ = lift mempty
+    compareTypes typeCondition parentType = do
+        types' <- asks $ Schema.types . schema
+        fragmentType <- lift
+            $ maybeToSeq
+            $ Type.lookupTypeCondition typeCondition types'
+        parentComposite <- lift
+            $ maybeToSeq
+            $ Type.outToComposite parentType
+        possibleFragments <- getPossibleTypes fragmentType
+        possibleParents <- getPossibleTypes parentComposite
+        let fragmentTypeName = compositeTypeName fragmentType
+        let parentTypeName = compositeTypeName parentComposite
+        if HashSet.null $ HashSet.intersection possibleFragments possibleParents
+            then pure (fragmentTypeName, parentTypeName)
+            else lift mempty
+    getPossibleTypeList (Type.CompositeObjectType objectType) =
+        pure [Schema.ObjectType objectType]
+    getPossibleTypeList (Type.CompositeUnionType unionType) =
+        let Out.UnionType _ _ members = unionType
+         in pure $ Schema.ObjectType <$> members
+    getPossibleTypeList (Type.CompositeInterfaceType interfaceType) =
+        let Out.InterfaceType typeName _ _ _ = interfaceType
+         in HashMap.lookupDefault [] typeName
+        <$> asks (Schema.implementations . schema)
+    getPossibleTypes compositeType
+        = foldr (HashSet.insert . internalTypeName) HashSet.empty
+        <$> getPossibleTypeList compositeType
+
+internalTypeName :: forall m. Schema.Type m -> Full.Name
+internalTypeName (Schema.ScalarType (Definition.ScalarType typeName _)) =
+    typeName
+internalTypeName (Schema.EnumType (Definition.EnumType typeName _ _)) = typeName
+internalTypeName (Schema.ObjectType (Out.ObjectType typeName _ _ _)) = typeName
+internalTypeName (Schema.InputObjectType (In.InputObjectType typeName _ _)) =
+    typeName
+internalTypeName (Schema.InterfaceType (Out.InterfaceType typeName _ _ _)) =
+    typeName
+internalTypeName (Schema.UnionType (Out.UnionType typeName _ _)) = typeName
+
+findSpreadTarget :: Full.Name -> ReaderT (Validation m1) Seq Full.TypeCondition
+findSpreadTarget fragmentName = do
+    ast' <- asks ast
+    let target = find (isSpreadTarget fragmentName) ast'
+    lift $ maybeToSeq $ target >>= extractTypeCondition
+  where
+    extractTypeCondition (viewFragment -> Just fragmentDefinition) =
+        let Full.FragmentDefinition _ typeCondition _ _ _ = fragmentDefinition
+            in Just typeCondition
+    extractTypeCondition _ = Nothing
+
+visitFragmentDefinition :: forall m
+    . Text
+    -> ValidationState m (Maybe Full.FragmentDefinition)
+visitFragmentDefinition fragmentName = do
+    definitions <- lift $ asks ast
+    visited <- gets (HashSet.member fragmentName)
+    modify (HashSet.insert fragmentName)
+    case find (isSpreadTarget fragmentName) definitions of
+        Just (viewFragment -> Just fragmentDefinition)
+            | not visited -> pure $ Just fragmentDefinition
+        _ -> pure Nothing
+
+-- | Variable usages must be compatible with the arguments they are passed to.
+--
+-- Validation failures occur when variables are used in the context of types
+-- that are complete mismatches, or if a nullable type in a variable is passed
+-- to a non‐null argument type.
+variablesInAllowedPositionRule :: forall m. Rule m
+variablesInAllowedPositionRule = OperationDefinitionRule $ \case
+    Full.OperationDefinition operationType _ variables _ selectionSet _ -> do
+        schema' <- asks schema
+        let root = go variables (toList selectionSet) . Type.CompositeObjectType
+        case operationType of
+            Full.Query -> root $ Schema.query schema'
+            Full.Mutation
+                | Just objectType <- Schema.mutation schema' -> root objectType
+            Full.Subscription
+                | Just objectType <- Schema.mutation schema' -> root objectType
+            _ -> lift mempty
+    _ -> lift mempty
+  where
+    go variables selections selectionType = mapReaderT (foldr (<>) Seq.empty)
+        $ flip evalStateT HashSet.empty
+        $ visitSelectionSet variables selectionType
+        $ toList selections
+    visitSelectionSet :: Foldable t
+        => [Full.VariableDefinition]
+        -> Type.CompositeType m
+        -> t Full.Selection
+        -> ValidationState m (Seq Error)
+    visitSelectionSet variables selectionType selections =
+        foldM (evaluateSelection variables selectionType) mempty selections
+    evaluateFieldSelection variables selections accumulator = \case
+        Just newParentType -> do
+            let folder = evaluateSelection variables newParentType
+            selectionErrors <- foldM folder accumulator selections
+            pure $ accumulator <> selectionErrors
+        Nothing -> pure accumulator
+    evaluateSelection :: [Full.VariableDefinition]
+        -> Type.CompositeType m
+        -> Seq Error
+        -> Full.Selection
+        -> ValidationState m (Seq Error)
+    evaluateSelection variables selectionType accumulator selection
+        | Full.FragmentSpreadSelection spread <- selection
+        , Full.FragmentSpread fragmentName _ _ <- spread = do
+            types' <- lift $ asks $ Schema.types . schema
+            nonVisitedFragmentDefinition <- visitFragmentDefinition fragmentName
+            case nonVisitedFragmentDefinition of
+                Just fragmentDefinition
+                    | Full.FragmentDefinition _ typeCondition _ _ _ <- fragmentDefinition
+                    , Just spreadType <- Type.lookupTypeCondition typeCondition types' -> do
+                        spreadErrors <- spreadVariables variables spread
+                        selectionErrors <- diveIntoSpread variables spreadType fragmentDefinition
+                        pure $ accumulator <> spreadErrors <> selectionErrors
+                _ -> lift $ lift mempty
+        | Full.FieldSelection fieldSelection <- selection
+        , Full.Field _ fieldName _ _ subselections _ <- fieldSelection =
+            case Type.lookupCompositeField fieldName selectionType of
+                Just (Out.Field _ typeField argumentTypes) -> do
+                    fieldErrors <- fieldVariables variables argumentTypes fieldSelection
+                    selectionErrors <- evaluateFieldSelection variables subselections accumulator
+                            $ Type.outToComposite typeField
+                    pure $ selectionErrors <> fieldErrors
+                Nothing -> pure accumulator
+        | Full.InlineFragmentSelection inlineSelection <- selection
+        , Full.InlineFragment typeCondition _ subselections _ <- inlineSelection = do
+            types' <- lift $ asks $ Schema.types . schema
+            let inlineType = fromMaybe selectionType
+                    $ typeCondition >>= flip Type.lookupTypeCondition types'
+            fragmentErrors <- inlineVariables variables inlineSelection
+            let folder = evaluateSelection variables inlineType
+            selectionErrors <- foldM folder accumulator subselections
+            pure $ accumulator <> fragmentErrors <> selectionErrors
+    inlineVariables variables inline
+        | Full.InlineFragment _ directives' _ _ <- inline =
+            mapDirectives variables directives'
+    fieldVariables :: [Full.VariableDefinition]
+        -> In.Arguments
+        -> Full.Field
+        -> ValidationState m (Seq Error)
+    fieldVariables variables argumentTypes fieldSelection = do
+        let Full.Field _ _ arguments directives' _ _ = fieldSelection
+        argumentErrors <- mapArguments variables argumentTypes arguments
+        directiveErrors <- mapDirectives variables directives'
+        pure $ argumentErrors <> directiveErrors
+    spreadVariables variables (Full.FragmentSpread _ directives' _) =
+        mapDirectives variables directives'
+    diveIntoSpread variables fieldType fragmentDefinition = do
+        let Full.FragmentDefinition _ _ directives' selections _ =
+                fragmentDefinition
+        selectionErrors <- visitSelectionSet variables fieldType selections
+        directiveErrors <- mapDirectives variables directives'
+        pure $ selectionErrors <> directiveErrors
+    findDirectiveVariables variables directive = do
+        let Full.Directive directiveName arguments _ = directive
+        directiveDefinitions <- lift $ asks $ Schema.directives . schema
+        case HashMap.lookup directiveName directiveDefinitions of
+            Just (Schema.Directive _ _ directiveArguments) ->
+                mapArguments variables directiveArguments arguments
+            Nothing -> pure mempty
+    mapArguments variables argumentTypes = fmap fold
+        . traverse (findArgumentVariables variables argumentTypes)
+    mapDirectives variables = fmap fold
+        <$> traverse (findDirectiveVariables variables)
+    lookupInputObject variables objectFieldValue locationInfo
+        | Full.Node{ node = Full.Object objectFields } <- objectFieldValue
+        , Just (expectedType, _) <- locationInfo
+        , In.InputObjectBaseType inputObjectType <- expectedType
+        , In.InputObjectType _ _ fieldTypes' <- inputObjectType =
+            fold <$> traverse (traverseObjectField variables fieldTypes') objectFields
+        | otherwise = pure mempty
+    maybeUsageAllowed variableName variables locationInfo
+        | Just (locationType, locationValue) <- locationInfo
+        , findVariableDefinition' <- findVariableDefinition variableName
+        , Just variableDefinition <- find findVariableDefinition' variables
+            = maybeToSeq
+            <$> isVariableUsageAllowed locationType locationValue variableDefinition
+        | otherwise = pure mempty
+    findArgumentVariables :: [Full.VariableDefinition]
+        -> HashMap Full.Name In.Argument
+        -> Full.Argument
+        -> ValidationState m (Seq Error)
+    findArgumentVariables variables argumentTypes argument
+        | Full.Argument argumentName argumentValue _ <- argument
+        , Full.Node{ node = Full.Variable variableName } <- argumentValue
+            = maybeUsageAllowed variableName variables
+            $ locationPair extractArgument argumentTypes argumentName
+        | Full.Argument argumentName argumentValue _ <- argument
+            = lookupInputObject variables argumentValue
+            $ locationPair extractArgument argumentTypes argumentName
+    extractField (In.InputField _ locationType locationValue) =
+        (locationType, locationValue)
+    extractArgument (In.Argument _ locationType locationValue) =
+        (locationType, locationValue)
+    locationPair extract fieldTypes name =
+        extract <$> HashMap.lookup name fieldTypes
+    traverseObjectField variables fieldTypes Full.ObjectField{..}
+        | Full.Node{ node = Full.Variable variableName } <- value
+            = maybeUsageAllowed variableName variables
+            $ locationPair extractField fieldTypes name
+        | otherwise = lookupInputObject variables value
+            $  locationPair extractField fieldTypes name
+    findVariableDefinition variableName variableDefinition =
+        let Full.VariableDefinition variableName' _ _ _ = variableDefinition
+         in variableName == variableName'
+    isVariableUsageAllowed locationType locationDefaultValue variableDefinition
+        | Full.VariableDefinition _ variableType _ _ <- variableDefinition
+        , Full.TypeNonNull _ <- variableType =
+            typesCompatibleOrError variableDefinition locationType
+        | Just nullableLocationType <- unwrapInType locationType
+        , Full.VariableDefinition _ variableType variableDefaultValue _ <-
+            variableDefinition
+        , hasNonNullVariableDefaultValue' <-
+            hasNonNullVariableDefaultValue variableDefaultValue
+        , hasLocationDefaultValue <- isJust locationDefaultValue =
+            if (hasNonNullVariableDefaultValue' || hasLocationDefaultValue)
+                && areTypesCompatible variableType nullableLocationType
+                then pure Nothing
+                else pure $ makeError variableDefinition locationType
+        | otherwise = typesCompatibleOrError variableDefinition locationType
+    typesCompatibleOrError variableDefinition locationType
+        | Full.VariableDefinition _ variableType _ _ <- variableDefinition
+        , areTypesCompatible variableType locationType = pure Nothing
+        | otherwise = pure $ makeError variableDefinition locationType
+    areTypesCompatible nonNullType (unwrapInType -> Just nullableLocationType)
+        | Full.TypeNonNull (Full.NonNullTypeNamed namedType) <- nonNullType =
+            areTypesCompatible (Full.TypeNamed namedType) nullableLocationType
+        | Full.TypeNonNull (Full.NonNullTypeList namedList) <- nonNullType =
+            areTypesCompatible (Full.TypeList namedList) nullableLocationType
+    areTypesCompatible _ (In.isNonNullType -> True) = False
+    areTypesCompatible (Full.TypeNonNull nonNullType) locationType
+        | Full.NonNullTypeNamed namedType <- nonNullType =
+            areTypesCompatible (Full.TypeNamed namedType) locationType
+        | Full.NonNullTypeList namedType <- nonNullType =
+            areTypesCompatible (Full.TypeList namedType) locationType
+    areTypesCompatible variableType locationType
+        | Full.TypeList itemVariableType <- variableType
+        , In.ListType itemLocationType <- locationType =
+            areTypesCompatible itemVariableType itemLocationType
+        | areIdentical variableType locationType = True
+        | otherwise = False
+    areIdentical (Full.TypeList typeList) (In.ListType itemLocationType) =
+        areIdentical typeList itemLocationType
+    areIdentical (Full.TypeNonNull nonNullType) locationType
+        | Full.NonNullTypeList nonNullList <- nonNullType
+        , In.NonNullListType  itemLocationType <- locationType =
+            areIdentical nonNullList itemLocationType
+        | Full.NonNullTypeNamed _ <- nonNullType
+        , In.ListBaseType _ <- locationType = False
+        | Full.NonNullTypeNamed nonNullList <- nonNullType
+        , In.isNonNullType locationType =
+            nonNullList == inputTypeName locationType
+    areIdentical (Full.TypeNamed _) (In.ListBaseType _) = False
+    areIdentical (Full.TypeNamed typeNamed) locationType
+        | not $ In.isNonNullType locationType =
+            typeNamed == inputTypeName locationType
+    areIdentical _ _ = False
+    hasNonNullVariableDefaultValue (Just (Full.Node Full.ConstNull _)) = False
+    hasNonNullVariableDefaultValue Nothing = False
+    hasNonNullVariableDefaultValue _ = True
+    makeError variableDefinition expectedType =
+        let Full.VariableDefinition variableName variableType _ location' =
+                variableDefinition
+         in Just $ Error
+            { message = concat
+                [ "Variable \"$"
+                , Text.unpack variableName
+                , "\" of type \""
+                , show variableType
+                , "\" used in position expecting type \""
+                , show expectedType
+                , "\"."
+                ]
+            , locations = [location']
+            }
+
+unwrapInType :: In.Type -> Maybe In.Type
+unwrapInType (In.NonNullScalarType nonNullType) =
+    Just $ In.NamedScalarType nonNullType
+unwrapInType (In.NonNullEnumType nonNullType) =
+    Just $ In.NamedEnumType nonNullType
+unwrapInType (In.NonNullInputObjectType nonNullType) =
+    Just $ In.NamedInputObjectType nonNullType
+unwrapInType (In.NonNullListType nonNullType) =
+    Just $ In.ListType nonNullType
+unwrapInType _ = Nothing
+
+-- | Literal values must be compatible with the type expected in the position
+-- they are found as per the coercion rules.
+--
+-- The type expected in a position include the type defined by the argument a
+-- value is provided for, the type defined by an input object field a value is
+-- provided for, and the type of a variable definition a default value is
+-- provided for.
+valuesOfCorrectTypeRule :: forall m. Rule m
+valuesOfCorrectTypeRule = ValueRule go constGo
+  where
+    go (Just inputType) value
+        | Just constValue <- toConstNode value =
+            lift $ check inputType constValue
+    go _ _ = lift mempty -- This rule checks only literals.
+    toConstNode Full.Node{..} = flip Full.Node location <$> toConst node
+    toConst (Full.Variable _) = Nothing
+    toConst (Full.Int integer) = Just $ Full.ConstInt integer
+    toConst (Full.Float double) = Just $ Full.ConstFloat double
+    toConst (Full.String string) = Just $ Full.ConstString string
+    toConst (Full.Boolean boolean) = Just $ Full.ConstBoolean boolean
+    toConst Full.Null = Just Full.ConstNull
+    toConst (Full.Enum enum) = Just $ Full.ConstEnum enum
+    toConst (Full.List values) =
+        Just $ Full.ConstList $ catMaybes $ toConstNode <$> values
+    toConst (Full.Object fields) = Just $ Full.ConstObject
+        $ catMaybes $ constObjectField <$> fields
+    constObjectField Full.ObjectField{..}
+        | Just constValue <- toConstNode value =
+            Just $ Full.ObjectField name constValue location
+        | otherwise = Nothing
+    constGo Nothing = const $ lift mempty
+    constGo (Just inputType) = lift . check inputType
+    check :: In.Type -> Full.Node Full.ConstValue -> Seq Error
+    check _ Full.Node{ node = Full.ConstNull } =
+        mempty -- Ignore, required fields are checked elsewhere.
+    check (In.ScalarBaseType scalarType) Full.Node{ node }
+        | Definition.ScalarType "Int" _ <- scalarType
+        , Full.ConstInt _ <- node = mempty
+        | Definition.ScalarType "Boolean" _ <- scalarType
+        , Full.ConstBoolean _ <- node = mempty
+        | Definition.ScalarType "String" _ <- scalarType
+        , Full.ConstString _ <- node = mempty
+        | Definition.ScalarType "ID" _ <- scalarType
+        , Full.ConstString _ <- node = mempty
+        | Definition.ScalarType "ID" _ <- scalarType
+        , Full.ConstInt _ <- node = mempty
+        | Definition.ScalarType "Float" _ <- scalarType
+        , Full.ConstFloat _ <- node = mempty
+        | Definition.ScalarType "Float" _ <- scalarType
+        , Full.ConstInt _ <- node = mempty
+    check (In.EnumBaseType enumType) Full.Node{ node }
+        | Definition.EnumType _ _ members <- enumType
+        , Full.ConstEnum memberValue <- node
+        , HashMap.member memberValue members = mempty
+    check (In.InputObjectBaseType objectType) Full.Node{ node }
+        -- Skip, objects are checked recursively by the validation traverser.
+        | In.InputObjectType{}  <- objectType
+        , Full.ConstObject{} <- node = mempty
+    check (In.ListBaseType listType) constValue@Full.Node{ .. }
+        | Full.ConstList values <- node =
+            foldMap (checkNull listType) values
+        | otherwise = check listType constValue
+    check inputType Full.Node{ .. } = pure $ Error
+        { message = concat
+            [ "Value "
+            , show node
+            , " cannot be coerced to type \""
+            , show inputType
+            , "\"."
+            ]
+        , locations = [location]
+        }
+    checkNull inputType constValue =
+        let checkResult = check inputType constValue
+         in case null checkResult of
+            True
+                | Just unwrappedType <- unwrapInType inputType
+                , Full.Node{ node = Full.ConstNull, .. } <- constValue ->
+                    pure $ Error
+                        { message = concat
+                            [ "List of non-null values of type \""
+                            , show unwrappedType
+                            , "\" cannot contain null values."
+                            ]
+                        , locations = [location]
+                        }
+                | otherwise -> mempty
+            _ -> checkResult
+

stack.yaml

@@ -1,9 +0,0 @@
-resolver: lts-16.20
-
-packages:
-- .
-
-extra-deps: []
-flags: {}
-
-pvp-bounds: lower

tests/Language/GraphQL/AST/DocumentSpec.hs

@@ -0,0 +1,20 @@
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE OverloadedStrings #-}
+module Language.GraphQL.AST.DocumentSpec
+    ( spec
+    ) where
+
+import Language.GraphQL.AST.Document
+import Test.Hspec (Spec, describe, it, shouldBe)
+
+spec :: Spec
+spec = do
+    describe "Document" $ do
+        it "shows objects" $
+            let zero = Location 0 0
+                object = ConstObject
+                    [ ObjectField "field1" (Node (ConstFloat 1.2) zero) zero
+                    , ObjectField "field2" (Node ConstNull zero) zero
+                    ]
+                expected = "{ field1: 1.2, field2: null }"
+             in show object `shouldBe` expected

tests/Language/GraphQL/AST/EncoderSpec.hs

@@ -6,10 +6,10 @@ module Language.GraphQL.AST.EncoderSpec
 
 import qualified Language.GraphQL.AST.Document as Full
 import Language.GraphQL.AST.Encoder
+import Language.GraphQL.TH
 import Test.Hspec (Spec, context, describe, it, shouldBe, shouldStartWith, shouldEndWith, shouldNotContain)
 import Test.QuickCheck (choose, oneof, forAll)
-import Text.RawString.QQ (r)
+import qualified Data.Text.Lazy as Text.Lazy
-import Data.Text.Lazy (cons, toStrict, unpack)
 
 spec :: Spec
 spec = do
@@ -48,23 +48,32 @@ spec = do
             it "uses strings for short string values" $
                 value pretty (Full.String "Short text") `shouldBe` "\"Short text\""
             it "uses block strings for text with new lines, with newline symbol" $
-                value pretty (Full.String "Line 1\nLine 2")
+                let expected = [gql|
-                    `shouldBe` [r|"""
+                  """
-  Line 1
+                    Line 1
-  Line 2
+                    Line 2
-"""|]
+                  """
+                |]
+                    actual = value pretty $ Full.String "Line 1\nLine 2"
+                 in actual `shouldBe` expected
             it "uses block strings for text with new lines, with CR symbol" $
-                value pretty (Full.String "Line 1\rLine 2")
+                let expected = [gql|
-                    `shouldBe` [r|"""
+                  """
-  Line 1
+                    Line 1
-  Line 2
+                    Line 2
-"""|]
+                  """
+                |]
+                    actual = value pretty $ Full.String "Line 1\rLine 2"
+                 in actual `shouldBe` expected
             it "uses block strings for text with new lines, with CR symbol followed by newline" $
-                value pretty (Full.String "Line 1\r\nLine 2")
+                let expected = [gql|
-                    `shouldBe` [r|"""
+                  """
-  Line 1
+                    Line 1
-  Line 2
+                    Line 2
-"""|]
+                  """
+                |]
+                    actual = value pretty $ Full.String "Line 1\r\nLine 2"
+                 in actual `shouldBe` expected
             it "encodes as one line string if has escaped symbols" $ do
                 let
                   genNotAllowedSymbol = oneof
@@ -76,48 +85,74 @@ spec = do
 
                 forAll genNotAllowedSymbol $ \x -> do
                     let
-                      rawValue = "Short \n" <> cons x "text"
+                      rawValue = "Short \n" <> Text.Lazy.cons x "text"
-                      encoded = value pretty (Full.String $ toStrict rawValue)
+                      encoded = value pretty
-                    shouldStartWith (unpack encoded) "\""
+                          $ Full.String $ Text.Lazy.toStrict rawValue
-                    shouldEndWith (unpack encoded) "\""
+                    shouldStartWith (Text.Lazy.unpack encoded) "\""
-                    shouldNotContain (unpack encoded) "\"\"\""
+                    shouldEndWith (Text.Lazy.unpack encoded) "\""
+                    shouldNotContain (Text.Lazy.unpack encoded) "\"\"\""
 
-            it "Hello world" $ value pretty (Full.String "Hello,\n  World!\n\nYours,\n  GraphQL.")
+            it "Hello world" $
-              `shouldBe` [r|"""
+                let actual = value pretty
-  Hello,
+                        $ Full.String "Hello,\n  World!\n\nYours,\n  GraphQL."
-    World!
+                    expected = [gql|
+                      """
+                        Hello,
+                          World!
 
-  Yours,
+                        Yours,
-    GraphQL.
+                          GraphQL.
-"""|]
+                      """
+                    |]
+                  in actual `shouldBe` expected
 
-            it "has only newlines" $ value pretty (Full.String "\n") `shouldBe` [r|"""
+            it "has only newlines" $
+                let actual = value pretty $ Full.String "\n"
+                    expected = [gql|
+                      """
 
 
-"""|]
+                      """
+                    |]
+                 in actual `shouldBe` expected
             it "has newlines and one symbol at the begining" $
-              value pretty (Full.String "a\n\n") `shouldBe` [r|"""
+                let actual = value pretty $ Full.String "a\n\n"
-  a
+                    expected = [gql|
+                      """
+                        a
 
 
-"""|]
+                      """|]
+                 in actual `shouldBe` expected
             it "has newlines and one symbol at the end" $
-              value pretty (Full.String "\n\na") `shouldBe` [r|"""
+                let actual = value pretty $ Full.String "\n\na"
+                    expected = [gql|
+                      """
 
 
-  a
+                        a
-"""|]
+                      """
+                    |]
+                 in actual `shouldBe` expected
             it "has newlines and one symbol in the middle" $
-              value pretty (Full.String "\na\n") `shouldBe` [r|"""
+                let actual = value pretty $ Full.String "\na\n"
+                    expected = [gql|
+                      """
 
-  a
+                        a
 
-"""|]
+                      """
-            it "skip trailing whitespaces" $ value pretty (Full.String "  Short\ntext    ")
+                    |]
-              `shouldBe` [r|"""
+                 in actual `shouldBe` expected
-  Short
+            it "skip trailing whitespaces" $
-  text
+                let actual = value pretty $ Full.String "  Short\ntext    "
-"""|]
+                    expected = [gql|
+                      """
+                        Short
+                        text
+                      """
+                    |]
+                 in actual `shouldBe` expected
 
     describe "definition" $
         it "indents block strings in arguments" $
@@ -128,10 +163,13 @@ spec = do
                 fieldSelection = pure $ Full.FieldSelection field
                 operation = Full.DefinitionOperation
                     $ Full.SelectionSet fieldSelection location
-             in definition pretty operation `shouldBe` [r|{
+                expected = Text.Lazy.snoc [gql|
-  field(message: """
+                  {
-    line1
+                    field(message: """
-    line2
+                      line1
-  """)
+                      line2
-}
+                    """)
-|]
+                  }
+                |] '\n'
+                actual = definition pretty operation
+             in actual `shouldBe` expected

tests/Language/GraphQL/AST/LexerSpec.hs

@@ -7,10 +7,10 @@ module Language.GraphQL.AST.LexerSpec
 import Data.Text (Text)
 import Data.Void (Void)
 import Language.GraphQL.AST.Lexer
+import Language.GraphQL.TH
 import Test.Hspec (Spec, context, describe, it)
 import Test.Hspec.Megaparsec (shouldParse, shouldFailOn, shouldSucceedOn)
 import Text.Megaparsec (ParseErrorBundle, parse)
-import Text.RawString.QQ (r)
 
 spec :: Spec
 spec = describe "Lexer" $ do
@@ -19,32 +19,32 @@ spec = describe "Lexer" $ do
             parse unicodeBOM "" `shouldSucceedOn` "\xfeff"
 
         it "lexes strings" $ do
-            parse string "" [r|"simple"|] `shouldParse` "simple"
+            parse string "" [gql|"simple"|] `shouldParse` "simple"
-            parse string "" [r|" white space "|] `shouldParse` " white space "
+            parse string "" [gql|" white space "|] `shouldParse` " white space "
-            parse string "" [r|"quote \""|] `shouldParse` [r|quote "|]
+            parse string "" [gql|"quote \""|] `shouldParse` [gql|quote "|]
-            parse string "" [r|"escaped \n"|] `shouldParse` "escaped \n"
+            parse string "" [gql|"escaped \n"|] `shouldParse` "escaped \n"
-            parse string "" [r|"slashes \\ \/"|] `shouldParse` [r|slashes \ /|]
+            parse string "" [gql|"slashes \\ \/"|] `shouldParse` [gql|slashes \ /|]
-            parse string "" [r|"unicode \u1234\u5678\u90AB\uCDEF"|]
+            parse string "" [gql|"unicode \u1234\u5678\u90AB\uCDEF"|]
                 `shouldParse` "unicode ሴ噸邫췯"
 
         it "lexes block string" $ do
-            parse blockString "" [r|"""simple"""|] `shouldParse` "simple"
+            parse blockString "" [gql|"""simple"""|] `shouldParse` "simple"
-            parse blockString "" [r|""" white space """|]
+            parse blockString "" [gql|""" white space """|]
                 `shouldParse` " white space "
-            parse blockString "" [r|"""contains " quote"""|]
+            parse blockString "" [gql|"""contains " quote"""|]
-                `shouldParse` [r|contains " quote|]
+                `shouldParse` [gql|contains " quote|]
-            parse blockString "" [r|"""contains \""" triplequote"""|]
+            parse blockString "" [gql|"""contains \""" triplequote"""|]
-                `shouldParse` [r|contains """ triplequote|]
+                `shouldParse` [gql|contains """ triplequote|]
             parse blockString "" "\"\"\"multi\nline\"\"\"" `shouldParse` "multi\nline"
             parse blockString "" "\"\"\"multi\rline\r\nnormalized\"\"\""
                 `shouldParse` "multi\nline\nnormalized"
             parse blockString "" "\"\"\"multi\rline\r\nnormalized\"\"\""
                 `shouldParse` "multi\nline\nnormalized"
-            parse blockString "" [r|"""unescaped \n\r\b\t\f\u1234"""|]
+            parse blockString "" [gql|"""unescaped \n\r\b\t\f\u1234"""|]
-                `shouldParse` [r|unescaped \n\r\b\t\f\u1234|]
+                `shouldParse` [gql|unescaped \n\r\b\t\f\u1234|]
-            parse blockString "" [r|"""slashes \\ \/"""|]
+            parse blockString "" [gql|"""slashes \\ \/"""|]
-                `shouldParse` [r|slashes \\ \/|]
+                `shouldParse` [gql|slashes \\ \/|]
-            parse blockString "" [r|"""
+            parse blockString "" [gql|"""
 
                 spans
                   multiple
@@ -84,7 +84,7 @@ spec = describe "Lexer" $ do
 
     context "Implementation tests" $ do
         it "lexes empty block strings" $
-            parse blockString "" [r|""""""|] `shouldParse` ""
+            parse blockString "" [gql|""""""|] `shouldParse` ""
         it "lexes ampersand" $
             parse amp "" "&" `shouldParse` "&"
         it "lexes schema extensions" $

tests/Language/GraphQL/AST/ParserSpec.hs

@@ -6,11 +6,12 @@ module Language.GraphQL.AST.ParserSpec
 
 import Data.List.NonEmpty (NonEmpty(..))
 import Language.GraphQL.AST.Document
+import qualified Language.GraphQL.AST.DirectiveLocation as DirLoc
 import Language.GraphQL.AST.Parser
+import Language.GraphQL.TH
 import Test.Hspec (Spec, describe, it)
 import Test.Hspec.Megaparsec (shouldParse, shouldFailOn, shouldSucceedOn)
 import Text.Megaparsec (parse)
-import Text.RawString.QQ (r)
 
 spec :: Spec
 spec = describe "Parser" $ do
@@ -18,74 +19,74 @@ spec = describe "Parser" $ do
         parse document "" `shouldSucceedOn` "\xfeff{foo}"
 
     it "accepts block strings as argument" $
-        parse document "" `shouldSucceedOn` [r|{
+        parse document "" `shouldSucceedOn` [gql|{
               hello(text: """Argument""")
             }|]
 
     it "accepts strings as argument" $
-        parse document "" `shouldSucceedOn` [r|{
+        parse document "" `shouldSucceedOn` [gql|{
               hello(text: "Argument")
             }|]
 
     it "accepts two required arguments" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             mutation auth($username: String!, $password: String!){
               test
             }|]
 
     it "accepts two string arguments" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             mutation auth{
               test(username: "username", password: "password")
             }|]
 
     it "accepts two block string arguments" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             mutation auth{
               test(username: """username""", password: """password""")
             }|]
 
     it "parses minimal schema definition" $
-        parse document "" `shouldSucceedOn` [r|schema { query: Query }|]
+        parse document "" `shouldSucceedOn` [gql|schema { query: Query }|]
 
     it "parses minimal scalar definition" $
-        parse document "" `shouldSucceedOn` [r|scalar Time|]
+        parse document "" `shouldSucceedOn` [gql|scalar Time|]
 
     it "parses ImplementsInterfaces" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             type Person implements NamedEntity & ValuedEntity {
               name: String
             }
         |]
 
     it "parses a  type without ImplementsInterfaces" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             type Person {
               name: String
             }
         |]
 
     it "parses ArgumentsDefinition in an ObjectDefinition" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             type Person {
               name(first: String, last: String): String
             }
         |]
 
     it "parses minimal union type definition" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             union SearchResult = Photo | Person
         |]
 
     it "parses minimal interface type definition" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             interface NamedEntity {
               name: String
             }
         |]
 
     it "parses minimal enum type definition" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             enum Direction {
               NORTH
               EAST
@@ -95,7 +96,7 @@ spec = describe "Parser" $ do
         |]
 
     it "parses minimal enum type definition" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             enum Direction {
               NORTH
               EAST
@@ -105,7 +106,7 @@ spec = describe "Parser" $ do
         |]
 
     it "parses minimal input object type definition" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             input Point2D {
               x: Float
               y: Float
@@ -113,19 +114,69 @@ spec = describe "Parser" $ do
         |]
 
     it "parses minimal input enum definition with an optional pipe" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             directive @example on
               | FIELD
               | FRAGMENT_SPREAD
         |]
 
+    it "parses two minimal directive definitions" $
+        let directive nm loc =
+                TypeSystemDefinition
+                    (DirectiveDefinition
+                         (Description Nothing)
+                         nm
+                         (ArgumentsDefinition [])
+                         (loc :| []))
+            example1 =
+                directive "example1"
+                    (DirLoc.TypeSystemDirectiveLocation DirLoc.FieldDefinition)
+                    (Location {line = 1, column = 1})
+            example2 =
+                directive "example2"
+                    (DirLoc.ExecutableDirectiveLocation DirLoc.Field)
+                    (Location {line = 2, column = 1})
+            testSchemaExtension = example1 :| [ example2 ]
+            query = [gql|
+              directive @example1 on FIELD_DEFINITION
+              directive @example2 on FIELD
+            |]
+         in parse document "" query `shouldParse` testSchemaExtension
+
+    it "parses a directive definition with a default empty list argument" $
+        let directive nm loc args =
+                TypeSystemDefinition
+                    (DirectiveDefinition
+                         (Description Nothing)
+                         nm
+                         (ArgumentsDefinition
+                              [ InputValueDefinition
+                                    (Description Nothing)
+                                    argName
+                                    argType
+                                    argValue
+                                    []
+                              | (argName, argType, argValue) <- args])
+                         (loc :| []))
+            defn =
+                directive "test"
+                    (DirLoc.TypeSystemDirectiveLocation DirLoc.FieldDefinition)
+                    [("foo",
+                      TypeList (TypeNamed "String"),
+                      Just
+                          $ Node (ConstList [])
+                          $ Location {line = 1, column = 33})]
+                    (Location {line = 1, column = 1})
+            query = [gql|directive @test(foo: [String] = []) on FIELD_DEFINITION|]
+         in parse document "" query `shouldParse` (defn :| [ ])
+
     it "parses schema extension with a new directive" $
-        parse document "" `shouldSucceedOn`[r|
+        parse document "" `shouldSucceedOn`[gql|
             extend schema @newDirective
         |]
 
     it "parses schema extension with an operation type definition" $
-        parse document "" `shouldSucceedOn` [r|extend schema { query: Query }|]
+        parse document "" `shouldSucceedOn` [gql|extend schema { query: Query }|]
 
     it "parses schema extension with an operation type and directive" $
         let newDirective = Directive "newDirective" [] $ Location 1 15
@@ -134,25 +185,25 @@ spec = describe "Parser" $ do
                 $ OperationTypeDefinition Query "Query" :| []
             testSchemaExtension = TypeSystemExtension schemaExtension
                 $ Location 1 1
-            query = [r|extend schema @newDirective { query: Query }|]
+            query = [gql|extend schema @newDirective { query: Query }|]
          in parse document "" query `shouldParse` (testSchemaExtension :| [])
 
     it "parses an object extension" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             extend type Story {
               isHiddenLocally: Boolean
             }
         |]
 
     it "rejects variables in DefaultValue" $
-        parse document "" `shouldFailOn` [r|
+        parse document "" `shouldFailOn` [gql|
             query ($book: String = "Zarathustra", $author: String = $book) {
               title
             }
         |]
 
     it "parses documents beginning with a comment" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             """
             Query
             """
@@ -162,7 +213,7 @@ spec = describe "Parser" $ do
         |]
 
     it "parses subscriptions" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             subscription NewMessages {
               newMessage(roomId: 123) {
                 sender

tests/Language/GraphQL/ErrorSpec.hs

@@ -8,17 +8,29 @@ module Language.GraphQL.ErrorSpec
     ) where
 
 import qualified Data.Aeson as Aeson
-import qualified Data.Sequence as Seq
+import Data.List.NonEmpty (NonEmpty (..))
 import Language.GraphQL.Error
-import Test.Hspec ( Spec
+import Test.Hspec
-                  , describe
+    ( Spec
-                  , it
+    , describe
-                  , shouldBe
+    , it
-                  )
+    , shouldBe
+    )
+import Text.Megaparsec (PosState(..))
+import Text.Megaparsec.Error (ParseError(..), ParseErrorBundle(..))
+import Text.Megaparsec.Pos (SourcePos(..), mkPos)
 
 spec :: Spec
-spec = describe "singleError" $
+spec = describe "parseError" $
-    it "constructs an error with the given message" $
+    it "generates response with a single error" $ do
-        let errors'' = Seq.singleton $ Error "Message." [] []
+        let parseErrors = TrivialError 0 Nothing mempty :| []
-            expected = Response Aeson.Null errors''
+            posState = PosState
-         in singleError "Message." `shouldBe` expected
+                { pstateInput = ""
+                , pstateOffset = 0
+                , pstateSourcePos = SourcePos "" (mkPos 1) (mkPos 1)
+                , pstateTabWidth = mkPos 1
+                , pstateLinePrefix = ""
+                }
+        Response Aeson.Null actual <-
+            parseError (ParseErrorBundle parseErrors posState)
+        length actual `shouldBe` 1

tests/Language/GraphQL/Execute/OrderedMapSpec.hs

@@ -0,0 +1,72 @@
+{- This Source Code Form is subject to the terms of the Mozilla Public License,
+   v. 2.0. If a copy of the MPL was not distributed with this file, You can
+   obtain one at https://mozilla.org/MPL/2.0/. -}
+
+{-# LANGUAGE OverloadedStrings #-}
+
+module Language.GraphQL.Execute.OrderedMapSpec
+    ( spec
+    ) where
+
+import Language.GraphQL.Execute.OrderedMap (OrderedMap)
+import qualified Language.GraphQL.Execute.OrderedMap as OrderedMap
+import Test.Hspec (Spec, describe, it, shouldBe, shouldSatisfy)
+
+spec :: Spec
+spec =
+    describe "OrderedMap" $ do
+        it "creates an empty map" $
+            (mempty :: OrderedMap String) `shouldSatisfy` null
+
+        it "creates a singleton" $
+            let value :: String
+                value = "value"
+             in OrderedMap.size (OrderedMap.singleton "key" value) `shouldBe` 1
+
+        it "combines inserted vales" $
+            let key = "key"
+                map1 = OrderedMap.singleton key ("1" :: String)
+                map2 = OrderedMap.singleton key ("2" :: String)
+             in OrderedMap.lookup key (map1 <> map2) `shouldBe` Just "12"
+
+        it "shows the map" $
+            let actual = show
+                    $ OrderedMap.insert "key1" "1"
+                    $ OrderedMap.singleton "key2" ("2" :: String)
+                expected = "fromList [(\"key2\",\"2\"),(\"key1\",\"1\")]"
+             in actual `shouldBe` expected
+
+        it "traverses a map of just values" $
+            let actual = sequence
+                    $ OrderedMap.insert "key1" (Just "2")
+                    $ OrderedMap.singleton "key2" $ Just ("1" :: String)
+                expected = Just
+                    $ OrderedMap.insert "key1" "2"
+                    $ OrderedMap.singleton "key2" ("1" :: String)
+             in actual `shouldBe` expected
+
+        it "traverses a map with a Nothing" $
+            let actual = sequence
+                    $ OrderedMap.insert "key1" Nothing
+                    $ OrderedMap.singleton "key2" $ Just ("1" :: String)
+                expected = Nothing
+             in actual `shouldBe` expected
+
+        it "combines two maps preserving the order of the second one" $
+            let map1 :: OrderedMap String
+                map1 = OrderedMap.insert "key2" "2"
+                    $ OrderedMap.singleton "key1" "1"
+                map2 :: OrderedMap String
+                map2 = OrderedMap.insert "key4" "4"
+                    $ OrderedMap.singleton "key3" "3"
+                expected = OrderedMap.insert "key4" "4"
+                    $ OrderedMap.insert "key3" "3"
+                    $ OrderedMap.insert "key2" "2"
+                    $ OrderedMap.singleton "key1" "1"
+             in (map1 <> map2) `shouldBe` expected
+
+        it "replaces existing values" $
+            let key = "key"
+                actual = OrderedMap.replace key ("2" :: String)
+                        $ OrderedMap.singleton key ("1" :: String)
+             in OrderedMap.lookup key actual `shouldBe` Just "2"

tests/Language/GraphQL/ExecuteSpec.hs

@@ -8,34 +8,92 @@ module Language.GraphQL.ExecuteSpec
     ( spec
     ) where
 
-import Control.Exception (SomeException)
+import Control.Exception (Exception(..), SomeException)
+import Control.Monad.Catch (throwM)
 import Data.Aeson ((.=))
 import qualified Data.Aeson as Aeson
 import Data.Aeson.Types (emptyObject)
 import Data.Conduit
 import Data.HashMap.Strict (HashMap)
 import qualified Data.HashMap.Strict as HashMap
-import Language.GraphQL.AST (Document, Name)
+import Data.Typeable (cast)
+import Language.GraphQL.AST (Document, Location(..), Name)
 import Language.GraphQL.AST.Parser (document)
 import Language.GraphQL.Error
-import Language.GraphQL.Execute
+import Language.GraphQL.Execute (execute)
-import Language.GraphQL.Type as Type
+import Language.GraphQL.TH
-import Language.GraphQL.Type.Out as Out
+import qualified Language.GraphQL.Type.Schema as Schema
+import Language.GraphQL.Type
+import qualified Language.GraphQL.Type.In as In
+import qualified Language.GraphQL.Type.Out as Out
+import Prelude hiding (id)
 import Test.Hspec (Spec, context, describe, it, shouldBe)
 import Text.Megaparsec (parse)
-import Text.RawString.QQ (r)
+
+data PhilosopherException = PhilosopherException
+    deriving Show
+
+instance Exception PhilosopherException where
+    toException = toException. ResolverException
+    fromException e = do
+        ResolverException resolverException <- fromException e
+        cast resolverException
 
 philosopherSchema :: Schema (Either SomeException)
-philosopherSchema = schema queryType Nothing (Just subscriptionType) mempty
+philosopherSchema =
+    schemaWithTypes Nothing queryType Nothing subscriptionRoot extraTypes mempty
+  where
+    subscriptionRoot = Just subscriptionType
+    extraTypes =
+        [ Schema.ObjectType bookType
+        , Schema.ObjectType bookCollectionType
+        ]
 
 queryType :: Out.ObjectType (Either SomeException)
 queryType = Out.ObjectType "Query" Nothing []
-    $ HashMap.singleton "philosopher" 
+    $ HashMap.fromList
-    $ ValueResolver philosopherField
+    [ ("philosopher", ValueResolver philosopherField philosopherResolver)
-    $ pure $ Type.Object mempty
+    , ("genres", ValueResolver genresField genresResolver)
+    , ("count", ValueResolver countField countResolver)
+    ]
   where
     philosopherField =
-        Out.Field Nothing (Out.NonNullObjectType philosopherType) HashMap.empty
+        Out.Field Nothing (Out.NamedObjectType philosopherType)
+        $ HashMap.singleton "id"
+        $ In.Argument Nothing (In.NamedScalarType id) Nothing
+    philosopherResolver = pure $ Object mempty
+    genresField =
+        let fieldType = Out.ListType $ Out.NonNullScalarType string
+         in Out.Field Nothing fieldType HashMap.empty
+    genresResolver :: Resolve (Either SomeException)
+    genresResolver = throwM PhilosopherException
+    countField =
+        let fieldType = Out.NonNullScalarType int
+         in Out.Field Nothing fieldType HashMap.empty
+    countResolver = pure ""
+
+musicType :: Out.ObjectType (Either SomeException)
+musicType = Out.ObjectType "Music" Nothing []
+    $ HashMap.fromList resolvers
+  where
+    resolvers =
+        [ ("instrument", ValueResolver instrumentField instrumentResolver)
+        ]
+    instrumentResolver = pure $ String "piano"
+    instrumentField = Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
+
+poetryType :: Out.ObjectType (Either SomeException)
+poetryType = Out.ObjectType "Poetry" Nothing []
+    $ HashMap.fromList resolvers
+  where
+    resolvers =
+        [ ("genre", ValueResolver genreField genreResolver)
+        ]
+    genreResolver = pure $ String "Futurism"
+    genreField = Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
+
+interestType :: Out.UnionType (Either SomeException)
+interestType = Out.UnionType "Interest" Nothing [musicType, poetryType]
 
 philosopherType :: Out.ObjectType (Either SomeException)
 philosopherType = Out.ObjectType "Philosopher" Nothing []
@@ -44,19 +102,72 @@ philosopherType = Out.ObjectType "Philosopher" Nothing []
     resolvers =
         [ ("firstName", ValueResolver firstNameField firstNameResolver)
         , ("lastName", ValueResolver lastNameField lastNameResolver)
+        , ("school", ValueResolver schoolField schoolResolver)
+        , ("interest", ValueResolver interestField interestResolver)
+        , ("majorWork", ValueResolver majorWorkField majorWorkResolver)
+        , ("century", ValueResolver centuryField centuryResolver)
+        , ("firstLanguage", ValueResolver firstLanguageField firstLanguageResolver)
         ]
     firstNameField =
         Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
-    firstNameResolver = pure $ Type.String "Friedrich"
+    firstNameResolver = pure $ String "Friedrich"
     lastNameField
         = Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
-    lastNameResolver = pure $ Type.String "Nietzsche"
+    lastNameResolver = pure $ String "Nietzsche"
+    schoolField
+       = Out.Field Nothing (Out.NonNullEnumType schoolType) HashMap.empty
+    schoolResolver = pure $ Enum "EXISTENTIALISM"
+    interestField
+        = Out.Field Nothing (Out.NonNullUnionType interestType) HashMap.empty
+    interestResolver = pure
+        $ Object
+        $ HashMap.fromList [("instrument", "piano")]
+    majorWorkField
+        = Out.Field Nothing (Out.NonNullInterfaceType workType) HashMap.empty
+    majorWorkResolver = pure
+        $ Object
+        $ HashMap.fromList
+            [ ("title", "Also sprach Zarathustra: Ein Buch für Alle und Keinen")
+            ]
+    centuryField =
+        Out.Field Nothing (Out.NonNullScalarType int) HashMap.empty
+    centuryResolver = pure $ Float 18.5
+    firstLanguageField
+        = Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
+    firstLanguageResolver = pure Null
+
+workType :: Out.InterfaceType (Either SomeException)
+workType = Out.InterfaceType "Work" Nothing []
+    $ HashMap.fromList fields
+  where
+    fields = [("title", titleField)]
+    titleField = Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
+
+bookType :: Out.ObjectType (Either SomeException)
+bookType = Out.ObjectType "Book" Nothing [workType]
+    $ HashMap.fromList resolvers
+  where
+    resolvers =
+        [ ("title", ValueResolver titleField titleResolver)
+        ]
+    titleField = Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
+    titleResolver = pure "Also sprach Zarathustra: Ein Buch für Alle und Keinen"
+
+bookCollectionType :: Out.ObjectType (Either SomeException)
+bookCollectionType = Out.ObjectType "Book" Nothing [workType]
+    $ HashMap.fromList resolvers
+  where
+    resolvers =
+        [ ("title", ValueResolver titleField titleResolver)
+        ]
+    titleField = Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
+    titleResolver = pure "The Three Critiques"
 
 subscriptionType :: Out.ObjectType (Either SomeException)
 subscriptionType = Out.ObjectType "Subscription" Nothing []
     $ HashMap.singleton "newQuote"
-    $ EventStreamResolver quoteField (pure $ Type.Object mempty)
+    $ EventStreamResolver quoteField (pure $ Object mempty)
-    $ pure $ yield $ Type.Object mempty
+    $ pure $ yield $ Object mempty
   where
     quoteField =
         Out.Field Nothing (Out.NonNullObjectType quoteType) HashMap.empty
@@ -70,6 +181,13 @@ quoteType = Out.ObjectType "Quote" Nothing []
     quoteField =
         Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
 
+schoolType :: EnumType
+schoolType = EnumType "School" Nothing $ HashMap.fromList
+    [ ("NOMINALISM", EnumValue Nothing)
+    , ("REALISM", EnumValue Nothing)
+    , ("IDEALISM", EnumValue Nothing)
+    ]
+
 type EitherStreamOrValue = Either
     (ResponseEventStream (Either SomeException) Aeson.Value)
     (Response Aeson.Value)
@@ -82,7 +200,7 @@ spec :: Spec
 spec =
     describe "execute" $ do
         it "rejects recursive fragments" $
-            let sourceQuery = [r|
+            let sourceQuery = [gql|
               {
                 ...cyclicFragment
               }
@@ -118,6 +236,121 @@ spec =
                     Right (Right actual) = either (pure . parseError) execute'
                         $ parse document "" "{ philosopher { firstName } philosopher { lastName } }"
                 in actual `shouldBe` expected
+
+            it "errors on invalid output enum values" $
+                let data'' = Aeson.object
+                        [ "philosopher" .= Aeson.Null
+                        ]
+                    executionErrors = pure $ Error
+                        { message =
+                            "Value completion error. Expected type !School, found: EXISTENTIALISM."
+                        , locations = [Location 1 17]
+                        , path = [Segment "philosopher", Segment "school"]
+                        }
+                    expected = Response data'' executionErrors
+                    Right (Right actual) = either (pure . parseError) execute'
+                        $ parse document "" "{ philosopher { school } }"
+                in actual `shouldBe` expected
+
+            it "gives location information for non-null unions" $
+                let data'' = Aeson.object
+                        [ "philosopher" .= Aeson.Null
+                        ]
+                    executionErrors = pure $ Error
+                        { message =
+                            "Value completion error. Expected type !Interest, found: { instrument: \"piano\" }."
+                        , locations = [Location 1 17]
+                        , path = [Segment "philosopher", Segment "interest"]
+                        }
+                    expected = Response data'' executionErrors
+                    Right (Right actual) = either (pure . parseError) execute'
+                        $ parse document "" "{ philosopher { interest } }"
+                in actual `shouldBe` expected
+
+            it "gives location information for invalid interfaces" $
+                let data'' = Aeson.object
+                        [ "philosopher" .= Aeson.Null
+                        ]
+                    executionErrors = pure $ Error
+                        { message
+                            = "Value completion error. Expected type !Work, found:\
+                            \ { title: \"Also sprach Zarathustra: Ein Buch f\252r Alle und Keinen\" }."
+                        , locations = [Location 1 17]
+                        , path = [Segment "philosopher", Segment "majorWork"]
+                        }
+                    expected = Response data'' executionErrors
+                    Right (Right actual) = either (pure . parseError) execute'
+                        $ parse document "" "{ philosopher { majorWork { title } } }"
+                in actual `shouldBe` expected
+
+            it "gives location information for invalid scalar arguments" $
+                let data'' = Aeson.object
+                        [ "philosopher" .= Aeson.Null
+                        ]
+                    executionErrors = pure $ Error
+                        { message =
+                            "Argument \"id\" has invalid type. Expected type ID, found: True."
+                        , locations = [Location 1 15]
+                        , path = [Segment "philosopher"]
+                        }
+                    expected = Response data'' executionErrors
+                    Right (Right actual) = either (pure . parseError) execute'
+                        $ parse document "" "{ philosopher(id: true) { lastName } }"
+                in actual `shouldBe` expected
+
+            it "gives location information for failed result coercion" $
+                let data'' = Aeson.object
+                        [ "philosopher" .= Aeson.Null
+                        ]
+                    executionErrors = pure $ Error
+                        { message = "Unable to coerce result to !Int."
+                        , locations = [Location 1 26]
+                        , path = [Segment "philosopher", Segment "century"]
+                        }
+                    expected = Response data'' executionErrors
+                    Right (Right actual) = either (pure . parseError) execute'
+                        $ parse document "" "{ philosopher(id: \"1\") { century } }"
+                in actual `shouldBe` expected
+
+            it "gives location information for failed result coercion" $
+                let data'' = Aeson.object
+                        [ "genres" .= Aeson.Null
+                        ]
+                    executionErrors = pure $ Error
+                        { message = "PhilosopherException"
+                        , locations = [Location 1 3]
+                        , path = [Segment "genres"]
+                        }
+                    expected = Response data'' executionErrors
+                    Right (Right actual) = either (pure . parseError) execute'
+                        $ parse document "" "{ genres }"
+                in actual `shouldBe` expected
+
+            it "sets data to null if a root field isn't nullable" $
+                let executionErrors = pure $ Error
+                        { message = "Unable to coerce result to !Int."
+                        , locations = [Location 1 3]
+                        , path = [Segment "count"]
+                        }
+                    expected = Response Aeson.Null executionErrors
+                    Right (Right actual) = either (pure . parseError) execute'
+                        $ parse document "" "{ count }"
+                in actual `shouldBe` expected
+
+            it "detects nullability errors" $
+                let data'' = Aeson.object
+                        [ "philosopher" .= Aeson.Null
+                        ]
+                    executionErrors = pure $ Error
+                        { message = "Value completion error. Expected type !String, found: null."
+                        , locations = [Location 1 26]
+                        , path = [Segment "philosopher", Segment "firstLanguage"]
+                        }
+                    expected = Response data'' executionErrors
+                    Right (Right actual) = either (pure . parseError) execute'
+                        $ parse document "" "{ philosopher(id: \"1\") { firstLanguage } }"
+                in actual `shouldBe` expected
+
         context "Subscription" $
             it "subscribes" $
                 let data'' = Aeson.object

tests/Language/GraphQL/Validate/RulesSpec.hs

@@ -0,0 +1,962 @@
+{- This Source Code Form is subject to the terms of the Mozilla Public License,
+   v. 2.0. If a copy of the MPL was not distributed with this file, You can
+   obtain one at https://mozilla.org/MPL/2.0/. -}
+
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes #-}
+
+module Language.GraphQL.Validate.RulesSpec
+    ( spec
+    ) where
+
+import Data.Foldable (toList)
+import qualified Data.HashMap.Strict as HashMap
+import Data.Text (Text)
+import qualified Language.GraphQL.AST as AST
+import Language.GraphQL.TH
+import Language.GraphQL.Type
+import qualified Language.GraphQL.Type.In as In
+import qualified Language.GraphQL.Type.Out as Out
+import Language.GraphQL.Validate
+import Test.Hspec (Spec, context, describe, it, shouldBe, shouldContain)
+import Text.Megaparsec (parse, errorBundlePretty)
+
+petSchema :: Schema IO
+petSchema = schema queryType Nothing (Just subscriptionType) mempty
+
+queryType :: ObjectType IO
+queryType = ObjectType "Query" Nothing [] $ HashMap.fromList
+    [ ("dog", dogResolver)
+    , ("cat", catResolver)
+    , ("findDog", findDogResolver)
+    ]
+  where
+    dogField = Field Nothing (Out.NamedObjectType dogType) mempty
+    dogResolver = ValueResolver dogField $ pure Null
+    findDogArguments = HashMap.singleton "complex"
+        $ In.Argument Nothing (In.NonNullInputObjectType dogDataType) Nothing
+    findDogField = Field Nothing (Out.NamedObjectType dogType) findDogArguments
+    findDogResolver = ValueResolver findDogField $ pure Null
+    catField = Field Nothing (Out.NamedObjectType catType) mempty
+    catResolver = ValueResolver catField $ pure Null
+
+catCommandType :: EnumType
+catCommandType = EnumType "CatCommand" Nothing $ HashMap.fromList
+    [ ("JUMP", EnumValue Nothing)
+    ]
+
+catType :: ObjectType IO
+catType = ObjectType "Cat" Nothing [petType] $ HashMap.fromList
+    [ ("name", nameResolver)
+    , ("nickname", nicknameResolver)
+    , ("doesKnowCommands", doesKnowCommandsResolver)
+    , ("meowVolume", meowVolumeResolver)
+    ]
+  where
+    meowVolumeField = Field Nothing (Out.NamedScalarType int) mempty
+    meowVolumeResolver = ValueResolver meowVolumeField $ pure $ Int 3
+    doesKnowCommandsType = In.NonNullListType
+        $ In.NonNullEnumType catCommandType
+    doesKnowCommandsField = Field Nothing (Out.NonNullScalarType boolean)
+        $ HashMap.singleton "catCommands"
+        $ In.Argument Nothing doesKnowCommandsType Nothing
+    doesKnowCommandsResolver = ValueResolver doesKnowCommandsField
+        $ pure $ Boolean True
+
+nameResolver :: Resolver IO
+nameResolver = ValueResolver nameField $ pure "Name"
+  where
+    nameField = Field Nothing (Out.NonNullScalarType string) mempty
+
+nicknameResolver :: Resolver IO
+nicknameResolver = ValueResolver nicknameField $ pure "Nickname"
+  where
+    nicknameField = Field Nothing (Out.NamedScalarType string) mempty
+
+dogCommandType :: EnumType
+dogCommandType = EnumType "DogCommand" Nothing $ HashMap.fromList
+    [ ("SIT", EnumValue Nothing)
+    , ("DOWN", EnumValue Nothing)
+    , ("HEEL", EnumValue Nothing)
+    ]
+
+dogType :: ObjectType IO
+dogType = ObjectType "Dog" Nothing [petType] $ HashMap.fromList
+    [ ("name", nameResolver)
+    , ("nickname", nicknameResolver)
+    , ("barkVolume", barkVolumeResolver)
+    , ("doesKnowCommand", doesKnowCommandResolver)
+    , ("isHousetrained", isHousetrainedResolver)
+    , ("owner", ownerResolver)
+    ]
+  where
+    barkVolumeField = Field Nothing (Out.NamedScalarType int) mempty
+    barkVolumeResolver = ValueResolver barkVolumeField $ pure $ Int 3
+    doesKnowCommandField = Field Nothing (Out.NonNullScalarType boolean)
+        $ HashMap.singleton "dogCommand"
+        $ In.Argument Nothing (In.NonNullEnumType dogCommandType) Nothing
+    doesKnowCommandResolver = ValueResolver doesKnowCommandField
+        $ pure $ Boolean True
+    isHousetrainedField = Field Nothing (Out.NonNullScalarType boolean)
+        $ HashMap.singleton "atOtherHomes"
+        $ In.Argument Nothing (In.NamedScalarType boolean) Nothing
+    isHousetrainedResolver = ValueResolver isHousetrainedField
+        $ pure $ Boolean True
+    ownerField = Field Nothing (Out.NamedObjectType humanType) mempty
+    ownerResolver = ValueResolver ownerField $ pure Null
+
+dogDataType :: InputObjectType
+dogDataType = InputObjectType "DogData" Nothing
+    $ HashMap.singleton "name" nameInputField
+  where
+    nameInputField = InputField Nothing (In.NonNullScalarType string) Nothing
+
+sentientType :: InterfaceType IO
+sentientType = InterfaceType "Sentient" Nothing []
+    $ HashMap.singleton "name"
+    $ Field Nothing (Out.NonNullScalarType string) mempty
+
+petType :: InterfaceType IO
+petType = InterfaceType "Pet" Nothing []
+    $ HashMap.singleton "name"
+    $ Field Nothing (Out.NonNullScalarType string) mempty
+
+subscriptionType :: ObjectType IO
+subscriptionType = ObjectType "Subscription" Nothing [] $ HashMap.fromList
+    [ ("newMessage", newMessageResolver)
+    , ("disallowedSecondRootField", newMessageResolver)
+    ]
+  where
+    newMessageField = Field Nothing (Out.NonNullObjectType messageType) mempty
+    newMessageResolver = ValueResolver newMessageField
+        $ pure $ Object HashMap.empty
+
+messageType :: ObjectType IO
+messageType = ObjectType "Message" Nothing [] $ HashMap.fromList
+    [ ("sender", senderResolver)
+    , ("body", bodyResolver)
+    ]
+  where
+    senderField = Field Nothing (Out.NonNullScalarType string) mempty
+    senderResolver = ValueResolver senderField $ pure "Sender"
+    bodyField = Field Nothing (Out.NonNullScalarType string) mempty
+    bodyResolver = ValueResolver bodyField $ pure "Message body."
+
+humanType :: ObjectType IO
+humanType = ObjectType "Human" Nothing [sentientType] $ HashMap.fromList
+    [ ("name", nameResolver)
+    , ("pets", petsResolver)
+    ]
+  where
+    petsField =
+        Field Nothing (Out.ListType $ Out.NonNullInterfaceType petType) mempty
+    petsResolver = ValueResolver petsField $ pure $ List []
+
+validate :: Text -> [Error]
+validate queryString =
+    case parse AST.document "" queryString of
+        Left parseErrors -> error $ errorBundlePretty parseErrors
+        Right ast -> toList $ document petSchema specifiedRules ast
+
+spec :: Spec
+spec =
+    describe "document" $ do
+        context "executableDefinitionsRule" $
+            it "rejects type definitions" $
+                let queryString = [gql|
+                  query getDogName {
+                    dog {
+                      name
+                      color
+                    }
+                  }
+
+                  extend type Dog {
+                    color: String
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Definition must be OperationDefinition or \
+                            \FragmentDefinition."
+                        , locations = [AST.Location 8 1]
+                        }
+                 in validate queryString `shouldContain` [expected]
+
+        context "singleFieldSubscriptionsRule" $ do
+            it "rejects multiple subscription root fields" $
+                let queryString = [gql|
+                  subscription sub {
+                    newMessage {
+                      body
+                      sender
+                    }
+                    disallowedSecondRootField
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Subscription \"sub\" must select only one top \
+                            \level field."
+                        , locations = [AST.Location 1 1]
+                        }
+                 in validate queryString `shouldContain` [expected]
+
+            it "rejects multiple subscription root fields coming from a fragment" $
+                let queryString = [gql|
+                  subscription sub {
+                    ...multipleSubscriptions
+                  }
+
+                  fragment multipleSubscriptions on Subscription {
+                    newMessage {
+                      body
+                      sender
+                    }
+                    disallowedSecondRootField
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Subscription \"sub\" must select only one top \
+                            \level field."
+                        , locations = [AST.Location 1 1]
+                        }
+                 in validate queryString `shouldContain` [expected]
+
+            it "finds corresponding subscription fragment" $
+                let queryString = [gql|
+                  subscription sub {
+                    ...anotherSubscription
+                    ...multipleSubscriptions
+                  }
+                  fragment multipleSubscriptions on Subscription {
+                    newMessage {
+                      body
+                    }
+                    disallowedSecondRootField {
+                      sender
+                    }
+                  }
+                  fragment anotherSubscription on Subscription {
+                    newMessage {
+                      body
+                      sender
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Subscription \"sub\" must select only one top \
+                            \level field."
+                        , locations = [AST.Location 1 1]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "loneAnonymousOperationRule" $
+            it "rejects multiple anonymous operations" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      name
+                    }
+                  }
+
+                  query getName {
+                    dog {
+                      owner {
+                        name
+                      }
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "This anonymous operation must be the only defined \
+                            \operation."
+                        , locations = [AST.Location 1 1]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "uniqueOperationNamesRule" $
+            it "rejects operations with the same name" $
+                let queryString = [gql|
+                  query dogOperation {
+                    dog {
+                      name
+                    }
+                  }
+
+                  mutation dogOperation {
+                    mutateDog {
+                      id
+                    }
+                }
+                |]
+                    expected = Error
+                        { message =
+                            "There can be only one operation named \
+                            \\"dogOperation\"."
+                        , locations = [AST.Location 1 1, AST.Location 7 1]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "uniqueFragmentNamesRule" $
+            it "rejects fragments with the same name" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      ...fragmentOne
+                    }
+                  }
+
+                  fragment fragmentOne on Dog {
+                    name
+                  }
+
+                  fragment fragmentOne on Dog {
+                    owner {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "There can be only one fragment named \
+                            \\"fragmentOne\"."
+                        , locations = [AST.Location 7 1, AST.Location 11 1]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "fragmentSpreadTargetDefinedRule" $
+            it "rejects the fragment spread without a target" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      ...undefinedFragment
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fragment target \"undefinedFragment\" is \
+                            \undefined."
+                        , locations = [AST.Location 3 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "fragmentSpreadTypeExistenceRule" $ do
+            it "rejects fragment spreads without an unknown target type" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      ...notOnExistingType
+                    }
+                  }
+                  fragment notOnExistingType on NotInSchema {
+                    name
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fragment \"notOnExistingType\" is specified on \
+                            \type \"NotInSchema\" which doesn't exist in the \
+                            \schema."
+                        , locations = [AST.Location 3 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "rejects inline fragments without a target" $
+                let queryString = [gql|
+                  {
+                    ... on NotInSchema {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Inline fragment is specified on type \
+                            \\"NotInSchema\" which doesn't exist in the schema."
+                        , locations = [AST.Location 2 3]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "fragmentsOnCompositeTypesRule" $ do
+            it "rejects fragments on scalar types" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      ...fragOnScalar
+                    }
+                  }
+                  fragment fragOnScalar on Int {
+                    name
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fragment cannot condition on non composite type \
+                            \\"Int\"."
+                        , locations = [AST.Location 6 1]
+                        }
+                 in validate queryString `shouldContain` [expected]
+
+            it "rejects inline fragments on scalar types" $
+                let queryString = [gql|
+                  {
+                    ... on Boolean {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fragment cannot condition on non composite type \
+                            \\"Boolean\"."
+                        , locations = [AST.Location 2 3]
+                        }
+                in validate queryString `shouldContain` [expected]
+
+        context "noUnusedFragmentsRule" $
+            it "rejects unused fragments" $
+                let queryString = [gql|
+                  fragment nameFragment on Dog { # unused
+                    name
+                  }
+
+                  {
+                    dog {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fragment \"nameFragment\" is never used."
+                        , locations = [AST.Location 1 1]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "noFragmentCyclesRule" $
+            it "rejects spreads that form cycles" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      ...nameFragment
+                    }
+                  }
+                  fragment nameFragment on Dog {
+                    name
+                    ...barkVolumeFragment
+                  }
+                  fragment barkVolumeFragment on Dog {
+                    barkVolume
+                    ...nameFragment
+                  }
+                |]
+                    error1 = Error
+                        { message =
+                            "Cannot spread fragment \"barkVolumeFragment\" \
+                            \within itself (via barkVolumeFragment -> \
+                            \nameFragment -> barkVolumeFragment)."
+                        , locations = [AST.Location 10 1]
+                        }
+                    error2 = Error
+                        { message =
+                            "Cannot spread fragment \"nameFragment\" within \
+                            \itself (via nameFragment -> barkVolumeFragment -> \
+                            \nameFragment)."
+                        , locations = [AST.Location 6 1]
+                        }
+                 in validate queryString `shouldBe` [error1, error2]
+
+        context "uniqueArgumentNamesRule" $
+            it "rejects duplicate field arguments" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      isHousetrained(atOtherHomes: true, atOtherHomes: true)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "There can be only one argument named \
+                            \\"atOtherHomes\"."
+                        , locations = [AST.Location 3 20, AST.Location 3 40]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "uniqueDirectiveNamesRule" $
+            it "rejects more than one directive per location" $
+                let queryString = [gql|
+                  query ($foo: Boolean = true, $bar: Boolean = false) {
+                    dog @skip(if: $foo) @skip(if: $bar) {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "There can be only one directive named \"skip\"."
+                        , locations = [AST.Location 2 7, AST.Location 2 23]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "uniqueVariableNamesRule" $
+            it "rejects duplicate variables" $
+                let queryString = [gql|
+                  query houseTrainedQuery($atOtherHomes: Boolean, $atOtherHomes: Boolean) {
+                    dog {
+                      isHousetrained(atOtherHomes: $atOtherHomes)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "There can be only one variable named \
+                            \\"atOtherHomes\"."
+                        , locations = [AST.Location 1 25, AST.Location 1 49]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "variablesAreInputTypesRule" $
+            it "rejects non-input types as variables" $
+                let queryString = [gql|
+                  query takesDogBang($dog: Dog!) {
+                    dog {
+                      isHousetrained(atOtherHomes: $dog)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Variable \"$dog\" cannot be non-input type \
+                            \\"Dog\"."
+                        , locations = [AST.Location 1 20]
+                        }
+                 in validate queryString `shouldContain` [expected]
+
+        context "noUndefinedVariablesRule" $
+            it "rejects undefined variables" $
+                let queryString = [gql|
+                  query variableIsNotDefinedUsedInSingleFragment {
+                    dog {
+                      ...isHousetrainedFragment
+                    }
+                  }
+
+                  fragment isHousetrainedFragment on Dog {
+                    isHousetrained(atOtherHomes: $atOtherHomes)
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Variable \"$atOtherHomes\" is not defined by \
+                            \operation \
+                            \\"variableIsNotDefinedUsedInSingleFragment\"."
+                        , locations = [AST.Location 8 32]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "noUnusedVariablesRule" $
+            it "rejects unused variables" $
+                let queryString = [gql|
+                  query variableUnused($atOtherHomes: Boolean) {
+                    dog {
+                      isHousetrained
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Variable \"$atOtherHomes\" is never used in \
+                            \operation \"variableUnused\"."
+                        , locations = [AST.Location 1 22]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "uniqueInputFieldNamesRule" $
+            it "rejects duplicate fields in input objects" $
+                let queryString = [gql|
+                  {
+                    findDog(complex: { name: "Fido", name: "Jack" }) {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "There can be only one input field named \"name\"."
+                        , locations = [AST.Location 2 22, AST.Location 2 36]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "fieldsOnCorrectTypeRule" $
+            it "rejects undefined fields" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      meowVolume
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Cannot query field \"meowVolume\" on type \"Dog\"."
+                        , locations = [AST.Location 3 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "scalarLeafsRule" $
+            it "rejects scalar fields with not empty selection set" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      barkVolume {
+                        sinceWhen
+                      }
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Field \"barkVolume\" must not have a selection \
+                            \since type \"Int\" has no subfields."
+                        , locations = [AST.Location 3 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "knownArgumentNamesRule" $ do
+            it "rejects field arguments missing in the type" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      doesKnowCommand(command: CLEAN_UP_HOUSE, dogCommand: SIT)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Unknown argument \"command\" on field \
+                            \\"Dog.doesKnowCommand\"."
+                        , locations = [AST.Location 3 21]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "rejects directive arguments missing in the definition" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      isHousetrained(atOtherHomes: true) @include(unless: false, if: true)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Unknown argument \"unless\" on directive \
+                            \\"@include\"."
+                        , locations = [AST.Location 3 49]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "knownDirectiveNamesRule" $
+            it "rejects undefined directives" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      isHousetrained(atOtherHomes: true) @ignore(if: true)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message = "Unknown directive \"@ignore\"."
+                        , locations = [AST.Location 3 40]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "knownInputFieldNamesRule" $
+            it "rejects undefined input object fields" $
+                let queryString = [gql|
+                  {
+                    findDog(complex: { favoriteCookieFlavor: "Bacon", name: "Jack" }) {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Field \"favoriteCookieFlavor\" is not defined \
+                            \by type \"DogData\"."
+                        , locations = [AST.Location 2 22]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "directivesInValidLocationsRule" $
+            it "rejects directives in invalid locations" $
+                let queryString = [gql|
+                  query @skip(if: $foo) {
+                    dog {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Directive \"@skip\" may not be used on QUERY."
+                        , locations = [AST.Location 1 7]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "overlappingFieldsCanBeMergedRule" $ do
+            it "fails to merge fields of mismatching types" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      name: nickname
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fields \"name\" conflict because \"nickname\" and \
+                            \\"name\" are different fields. Use different \
+                            \aliases on the fields to fetch both if this was \
+                            \intentional."
+                        , locations = [AST.Location 3 5, AST.Location 4 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "fails if the arguments of the same field don't match" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      doesKnowCommand(dogCommand: SIT)
+                      doesKnowCommand(dogCommand: HEEL)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fields \"doesKnowCommand\" conflict because they \
+                            \have different arguments. Use different aliases \
+                            \on the fields to fetch both if this was \
+                            \intentional."
+                        , locations = [AST.Location 3 5, AST.Location 4 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "fails to merge same-named field and alias" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      doesKnowCommand(dogCommand: SIT)
+                      doesKnowCommand: isHousetrained(atOtherHomes: true)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fields \"doesKnowCommand\" conflict because \
+                            \\"doesKnowCommand\" and \"isHousetrained\" are \
+                            \different fields. Use different aliases on the \
+                            \fields to fetch both if this was intentional."
+                        , locations = [AST.Location 3 5, AST.Location 4 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "looks for fields after a successfully merged field pair" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      name
+                      doesKnowCommand(dogCommand: SIT)
+                    }
+                    dog {
+                      name
+                      doesKnowCommand: isHousetrained(atOtherHomes: true)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fields \"doesKnowCommand\" conflict because \
+                            \\"doesKnowCommand\" and \"isHousetrained\" are \
+                            \different fields. Use different aliases on the \
+                            \fields to fetch both if this was intentional."
+                        , locations = [AST.Location 4 5, AST.Location 8 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "possibleFragmentSpreadsRule" $ do
+            it "rejects object inline spreads outside object scope" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      ... on Cat {
+                        meowVolume
+                      }
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fragment cannot be spread here as objects of type \
+                            \\"Dog\" can never be of type \"Cat\"."
+                        , locations = [AST.Location 3 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "rejects object named spreads outside object scope" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      ... catInDogFragmentInvalid
+                    }
+                  }
+
+                  fragment catInDogFragmentInvalid on Cat {
+                    meowVolume
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Fragment \"catInDogFragmentInvalid\" cannot be \
+                            \spread here as objects of type \"Dog\" can never \
+                            \be of type \"Cat\"."
+                        , locations = [AST.Location 3 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "providedRequiredInputFieldsRule" $
+            it "rejects missing required input fields" $
+                let queryString = [gql|
+                  {
+                    findDog(complex: { name: null }) {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Input field \"name\" of type \"DogData\" is \
+                            \required, but it was not provided."
+                        , locations = [AST.Location 2 20]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "providedRequiredArgumentsRule" $ do
+            it "checks for (non-)nullable arguments" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      doesKnowCommand(dogCommand: null)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Field \"doesKnowCommand\" argument \"dogCommand\" \
+                            \of type \"DogCommand\" is required, but it was \
+                            \not provided."
+                        , locations = [AST.Location 3 5]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "variablesInAllowedPositionRule" $ do
+            it "rejects wrongly typed variable arguments" $
+                let queryString = [gql|
+                  query dogCommandArgQuery($dogCommandArg: DogCommand) {
+                    dog {
+                      doesKnowCommand(dogCommand: $dogCommandArg)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Variable \"$dogCommandArg\" of type \
+                            \\"DogCommand\" used in position expecting type \
+                            \\"!DogCommand\"."
+                        , locations = [AST.Location 1 26]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "rejects wrongly typed variable arguments" $
+                let queryString = [gql|
+                  query intCannotGoIntoBoolean($intArg: Int) {
+                    dog {
+                      isHousetrained(atOtherHomes: $intArg)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Variable \"$intArg\" of type \"Int\" used in \
+                            \position expecting type \"Boolean\"."
+                        , locations = [AST.Location 1 30]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+        context "valuesOfCorrectTypeRule" $ do
+            it "rejects values of incorrect types" $
+                let queryString = [gql|
+                  {
+                    dog {
+                      isHousetrained(atOtherHomes: 3)
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Value 3 cannot be coerced to type \"Boolean\"."
+                        , locations = [AST.Location 3 34]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "uses the location of a single list value" $
+                let queryString = [gql|
+                  {
+                    cat {
+                      doesKnowCommands(catCommands: [3])
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Value 3 cannot be coerced to type \"!CatCommand\"."
+                        , locations = [AST.Location 3 36]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "validates input object properties once" $
+                let queryString = [gql|
+                  {
+                    findDog(complex: { name: 3 }) {
+                      name
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "Value 3 cannot be coerced to type \"!String\"."
+                        , locations = [AST.Location 2 28]
+                        }
+                 in validate queryString `shouldBe` [expected]
+
+            it "checks for required list members" $
+                let queryString = [gql|
+                  {
+                    cat {
+                      doesKnowCommands(catCommands: [null])
+                    }
+                  }
+                |]
+                    expected = Error
+                        { message =
+                            "List of non-null values of type \"CatCommand\" \
+                            \cannot contain null values."
+                        , locations = [AST.Location 3 36]
+                        }
+                 in validate queryString `shouldBe` [expected]

tests/Language/GraphQL/ValidateSpec.hs

@@ -1,665 +0,0 @@
-{- This Source Code Form is subject to the terms of the Mozilla Public License,
-   v. 2.0. If a copy of the MPL was not distributed with this file, You can
-   obtain one at https://mozilla.org/MPL/2.0/. -}
-
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-
-module Language.GraphQL.ValidateSpec
-    ( spec
-    ) where
-
-import Data.Foldable (toList)
-import qualified Data.HashMap.Strict as HashMap
-import Data.Text (Text)
-import qualified Language.GraphQL.AST as AST
-import Language.GraphQL.Type
-import qualified Language.GraphQL.Type.In as In
-import qualified Language.GraphQL.Type.Out as Out
-import Language.GraphQL.Validate
-import Test.Hspec (Spec, describe, it, shouldBe, shouldContain)
-import Text.Megaparsec (parse)
-import Text.RawString.QQ (r)
-
-petSchema :: Schema IO
-petSchema = schema queryType Nothing (Just subscriptionType) mempty
-
-queryType :: ObjectType IO
-queryType = ObjectType "Query" Nothing [] $ HashMap.fromList
-    [ ("dog", dogResolver)
-    , ("findDog", findDogResolver)
-    ]
-  where
-    dogField = Field Nothing (Out.NamedObjectType dogType) mempty
-    dogResolver = ValueResolver dogField $ pure Null
-    findDogArguments = HashMap.singleton "complex"
-        $ In.Argument Nothing (In.NonNullInputObjectType dogDataType) Nothing
-    findDogField = Field Nothing (Out.NamedObjectType dogType) findDogArguments
-    findDogResolver = ValueResolver findDogField $ pure Null
-
-dogCommandType :: EnumType
-dogCommandType = EnumType "DogCommand" Nothing $ HashMap.fromList
-    [ ("SIT", EnumValue Nothing)
-    , ("DOWN", EnumValue Nothing)
-    , ("HEEL", EnumValue Nothing)
-    ]
-
-dogType :: ObjectType IO
-dogType = ObjectType "Dog" Nothing [petType] $ HashMap.fromList
-    [ ("name", nameResolver)
-    , ("nickname", nicknameResolver)
-    , ("barkVolume", barkVolumeResolver)
-    , ("doesKnowCommand", doesKnowCommandResolver)
-    , ("isHousetrained", isHousetrainedResolver)
-    , ("owner", ownerResolver)
-    ]
-  where
-    nameField = Field Nothing (Out.NonNullScalarType string) mempty
-    nameResolver = ValueResolver nameField $ pure "Name"
-    nicknameField = Field Nothing (Out.NamedScalarType string) mempty
-    nicknameResolver = ValueResolver nicknameField $ pure "Nickname"
-    barkVolumeField = Field Nothing (Out.NamedScalarType int) mempty
-    barkVolumeResolver = ValueResolver barkVolumeField $ pure $ Int 3
-    doesKnowCommandField = Field Nothing (Out.NonNullScalarType boolean)
-        $ HashMap.singleton "dogCommand"
-        $ In.Argument Nothing (In.NonNullEnumType dogCommandType) Nothing
-    doesKnowCommandResolver = ValueResolver doesKnowCommandField
-        $ pure $ Boolean True
-    isHousetrainedField = Field Nothing (Out.NonNullScalarType boolean)
-        $ HashMap.singleton "atOtherHomes"
-        $ In.Argument Nothing (In.NamedScalarType boolean) Nothing
-    isHousetrainedResolver = ValueResolver isHousetrainedField
-        $ pure $ Boolean True
-    ownerField = Field Nothing (Out.NamedObjectType humanType) mempty
-    ownerResolver = ValueResolver ownerField $ pure Null
-
-dogDataType :: InputObjectType
-dogDataType = InputObjectType "DogData" Nothing
-    $ HashMap.singleton "name" nameInputField
-  where
-    nameInputField = InputField Nothing (In.NonNullScalarType string) Nothing
-
-sentientType :: InterfaceType IO
-sentientType = InterfaceType "Sentient" Nothing []
-    $ HashMap.singleton "name"
-    $ Field Nothing (Out.NonNullScalarType string) mempty
-
-petType :: InterfaceType IO
-petType = InterfaceType "Pet" Nothing []
-    $ HashMap.singleton "name"
-    $ Field Nothing (Out.NonNullScalarType string) mempty
-
-subscriptionType :: ObjectType IO
-subscriptionType = ObjectType "Subscription" Nothing [] $ HashMap.fromList
-    [ ("newMessage", newMessageResolver)
-    , ("disallowedSecondRootField", newMessageResolver)
-    ]
-  where
-    newMessageField = Field Nothing (Out.NonNullObjectType messageType) mempty
-    newMessageResolver = ValueResolver newMessageField
-        $ pure $ Object HashMap.empty
-
-messageType :: ObjectType IO
-messageType = ObjectType "Message" Nothing [] $ HashMap.fromList
-    [ ("sender", senderResolver)
-    , ("body", bodyResolver)
-    ]
-  where
-    senderField = Field Nothing (Out.NonNullScalarType string) mempty
-    senderResolver = ValueResolver senderField $ pure "Sender"
-    bodyField = Field Nothing (Out.NonNullScalarType string) mempty
-    bodyResolver = ValueResolver bodyField $ pure "Message body."
-
-humanType :: ObjectType IO
-humanType = ObjectType "Human" Nothing [sentientType] $ HashMap.fromList
-    [ ("name", nameResolver)
-    , ("pets", petsResolver)
-    ]
-  where
-    nameField = Field Nothing (Out.NonNullScalarType string) mempty
-    nameResolver = ValueResolver nameField $ pure "Name"
-    petsField =
-        Field Nothing (Out.ListType $ Out.NonNullInterfaceType petType) mempty
-    petsResolver = ValueResolver petsField $ pure $ List []
-{-
-catOrDogType :: UnionType IO
-catOrDogType = UnionType "CatOrDog" Nothing [catType, dogType]
--}
-validate :: Text -> [Error]
-validate queryString =
-    case parse AST.document "" queryString of
-        Left _ -> []
-        Right ast -> toList $ document petSchema specifiedRules ast
-
-spec :: Spec
-spec =
-    describe "document" $ do
-        it "rejects type definitions" $
-            let queryString = [r|
-              query getDogName {
-                dog {
-                  name
-                  color
-                }
-              }
-
-              extend type Dog {
-                color: String
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Definition must be OperationDefinition or FragmentDefinition."
-                    , locations = [AST.Location 9 15]
-                    }
-               in validate queryString `shouldContain` [expected]
-
-        it "rejects multiple subscription root fields" $
-            let queryString = [r|
-              subscription sub {
-                newMessage {
-                  body
-                  sender
-                }
-                disallowedSecondRootField
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Subscription \"sub\" must select only one top level \
-                        \field."
-                    , locations = [AST.Location 2 15]
-                    }
-             in validate queryString `shouldContain` [expected]
-
-        it "rejects multiple subscription root fields coming from a fragment" $
-            let queryString = [r|
-              subscription sub {
-                ...multipleSubscriptions
-              }
-
-              fragment multipleSubscriptions on Subscription {
-                newMessage {
-                  body
-                  sender
-                }
-                disallowedSecondRootField
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Subscription \"sub\" must select only one top level \
-                        \field."
-                    , locations = [AST.Location 2 15]
-                    }
-             in validate queryString `shouldContain` [expected]
-
-        it "rejects multiple anonymous operations" $
-            let queryString = [r|
-              {
-                dog {
-                  name
-                }
-              }
-
-              query getName {
-                dog {
-                  owner {
-                    name
-                  }
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "This anonymous operation must be the only defined operation."
-                    , locations = [AST.Location 2 15]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects operations with the same name" $
-            let queryString = [r|
-              query dogOperation {
-                dog {
-                  name
-                }
-              }
-
-              mutation dogOperation {
-                mutateDog {
-                  id
-                }
-            }
-            |]
-                expected = Error
-                    { message =
-                        "There can be only one operation named \"dogOperation\"."
-                    , locations = [AST.Location 2 15, AST.Location 8 15]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects fragments with the same name" $
-            let queryString = [r|
-              {
-                dog {
-                  ...fragmentOne
-                }
-              }
-
-              fragment fragmentOne on Dog {
-                name
-              }
-
-              fragment fragmentOne on Dog {
-                owner {
-                  name
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "There can be only one fragment named \"fragmentOne\"."
-                    , locations = [AST.Location 8 15, AST.Location 12 15]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects the fragment spread without a target" $
-            let queryString = [r|
-              {
-                dog {
-                  ...undefinedFragment
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Fragment target \"undefinedFragment\" is undefined."
-                    , locations = [AST.Location 4 19]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects fragment spreads without an unknown target type" $
-            let queryString = [r|
-              {
-                dog {
-                  ...notOnExistingType
-                }
-              }
-              fragment notOnExistingType on NotInSchema {
-                name
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Fragment \"notOnExistingType\" is specified on type \
-                        \\"NotInSchema\" which doesn't exist in the schema."
-                    , locations = [AST.Location 4 19]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects inline fragments without a target" $
-            let queryString = [r|
-              {
-                ... on NotInSchema {
-                  name
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Inline fragment is specified on type \"NotInSchema\" \
-                        \which doesn't exist in the schema."
-                    , locations = [AST.Location 3 17]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects fragments on scalar types" $
-            let queryString = [r|
-              {
-                dog {
-                  ...fragOnScalar
-                }
-              }
-              fragment fragOnScalar on Int {
-                name
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Fragment cannot condition on non composite type \
-                        \\"Int\"."
-                    , locations = [AST.Location 7 15]
-                    }
-             in validate queryString `shouldContain` [expected]
-
-        it "rejects inline fragments on scalar types" $
-            let queryString = [r|
-              {
-                ... on Boolean {
-                  name
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Fragment cannot condition on non composite type \
-                        \\"Boolean\"."
-                    , locations = [AST.Location 3 17]
-                    }
-             in validate queryString `shouldContain` [expected]
-
-        it "rejects unused fragments" $
-            let queryString = [r|
-              fragment nameFragment on Dog { # unused
-                name
-              }
-
-              {
-                dog {
-                  name
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Fragment \"nameFragment\" is never used."
-                    , locations = [AST.Location 2 15]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects spreads that form cycles" $
-            let queryString = [r|
-              {
-                dog {
-                  ...nameFragment
-                }
-              }
-              fragment nameFragment on Dog {
-                name
-                ...barkVolumeFragment
-              }
-              fragment barkVolumeFragment on Dog {
-                barkVolume
-                ...nameFragment
-              }
-            |]
-                error1 = Error
-                    { message =
-                        "Cannot spread fragment \"barkVolumeFragment\" within \
-                        \itself (via barkVolumeFragment -> nameFragment -> \
-                        \barkVolumeFragment)."
-                    , locations = [AST.Location 11 15]
-                    }
-                error2 = Error
-                    { message =
-                        "Cannot spread fragment \"nameFragment\" within itself \
-                        \(via nameFragment -> barkVolumeFragment -> \
-                        \nameFragment)."
-                    , locations = [AST.Location 7 15]
-                    }
-             in validate queryString `shouldBe` [error1, error2]
-
-        it "rejects duplicate field arguments" $ do
-            let queryString = [r|
-              {
-                dog {
-                  isHousetrained(atOtherHomes: true, atOtherHomes: true)
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "There can be only one argument named \"atOtherHomes\"."
-                    , locations = [AST.Location 4 34, AST.Location 4 54]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects more than one directive per location" $ do
-            let queryString = [r|
-              query ($foo: Boolean = true, $bar: Boolean = false) {
-                dog @skip(if: $foo) @skip(if: $bar) {
-                  name
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "There can be only one directive named \"skip\"."
-                    , locations = [AST.Location 3 21, AST.Location 3 37]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects duplicate variables" $
-            let queryString = [r|
-              query houseTrainedQuery($atOtherHomes: Boolean, $atOtherHomes: Boolean) {
-                dog {
-                  isHousetrained(atOtherHomes: $atOtherHomes)
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "There can be only one variable named \"atOtherHomes\"."
-                    , locations = [AST.Location 2 39, AST.Location 2 63]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects non-input types as variables" $
-            let queryString = [r|
-              query takesDogBang($dog: Dog!) {
-                dog {
-                  isHousetrained(atOtherHomes: $dog)
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Variable \"$dog\" cannot be non-input type \"Dog\"."
-                    , locations = [AST.Location 2 34]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects undefined variables" $
-            let queryString = [r|
-              query variableIsNotDefinedUsedInSingleFragment {
-                dog {
-                  ...isHousetrainedFragment
-                }
-              }
-
-              fragment isHousetrainedFragment on Dog {
-                isHousetrained(atOtherHomes: $atOtherHomes)
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Variable \"$atOtherHomes\" is not defined by \
-                        \operation \
-                        \\"variableIsNotDefinedUsedInSingleFragment\"."
-                    , locations = [AST.Location 9 46]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects unused variables" $
-            let queryString = [r|
-              query variableUnused($atOtherHomes: Boolean) {
-                dog {
-                  isHousetrained
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Variable \"$atOtherHomes\" is never used in operation \
-                        \\"variableUnused\"."
-                    , locations = [AST.Location 2 36]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects duplicate fields in input objects" $
-            let queryString = [r|
-              {
-                findDog(complex: { name: "Fido", name: "Jack" }) {
-                  name
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "There can be only one input field named \"name\"."
-                    , locations = [AST.Location 3 36, AST.Location 3 50]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects undefined fields" $
-            let queryString = [r|
-              {
-                dog {
-                  meowVolume
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Cannot query field \"meowVolume\" on type \"Dog\"."
-                    , locations = [AST.Location 4 19]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects scalar fields with not empty selection set" $
-            let queryString = [r|
-              {
-                dog {
-                  barkVolume {
-                    sinceWhen
-                  }
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Field \"barkVolume\" must not have a selection since \
-                        \type \"Int\" has no subfields."
-                    , locations = [AST.Location 4 19]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects field arguments missing in the type" $
-            let queryString = [r|
-              {
-                dog {
-                  doesKnowCommand(command: CLEAN_UP_HOUSE, dogCommand: SIT)
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Unknown argument \"command\" on field \
-                        \\"Dog.doesKnowCommand\"."
-                    , locations = [AST.Location 4 35]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects directive arguments missing in the definition" $
-            let queryString = [r|
-              {
-                dog {
-                  isHousetrained(atOtherHomes: true) @include(unless: false, if: true)
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Unknown argument \"unless\" on directive \"@include\"."
-                    , locations = [AST.Location 4 63]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects undefined directives" $
-            let queryString = [r|
-              {
-                dog {
-                  isHousetrained(atOtherHomes: true) @ignore(if: true)
-                }
-              }
-            |]
-                expected = Error
-                    { message = "Unknown directive \"@ignore\"."
-                    , locations = [AST.Location 4 54]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects undefined input object fields" $
-            let queryString = [r|
-              {
-                findDog(complex: { favoriteCookieFlavor: "Bacon", name: "Jack" }) {
-                  name
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Field \"favoriteCookieFlavor\" is not defined \
-                        \by type \"DogData\"."
-                    , locations = [AST.Location 3 36]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects directives in invalid locations" $
-            let queryString = [r|
-              query @skip(if: $foo) {
-                dog {
-                  name
-                }
-              }
-            |]
-                expected = Error
-                    { message = "Directive \"@skip\" may not be used on QUERY."
-                    , locations = [AST.Location 2 21]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "rejects missing required input fields" $
-            let queryString = [r|
-              {
-                findDog(complex: { name: null }) {
-                  name
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Input field \"name\" of type \"DogData\" is required, \
-                        \but it was not provided."
-                    , locations = [AST.Location 3 34]
-                    }
-             in validate queryString `shouldBe` [expected]
-
-        it "finds corresponding subscription fragment" $
-            let queryString = [r|
-              subscription sub {
-                ...anotherSubscription
-                ...multipleSubscriptions
-              }
-              fragment multipleSubscriptions on Subscription {
-                newMessage {
-                  body
-                }
-                disallowedSecondRootField {
-                  sender
-                }
-              }
-              fragment anotherSubscription on Subscription {
-                newMessage {
-                  body
-                  sender
-                }
-              }
-            |]
-                expected = Error
-                    { message =
-                        "Subscription \"sub\" must select only one top level \
-                        \field."
-                    , locations = [AST.Location 2 15]
-                    }
-             in validate queryString `shouldBe` [expected]

tests/Test/DirectiveSpec.hs

@@ -12,11 +12,11 @@ import Data.Aeson (object, (.=))
 import qualified Data.Aeson as Aeson
 import qualified Data.HashMap.Strict as HashMap
 import Language.GraphQL
+import Language.GraphQL.TH
 import Language.GraphQL.Type
 import qualified Language.GraphQL.Type.Out as Out
 import Test.Hspec (Spec, describe, it)
 import Test.Hspec.GraphQL
-import Text.RawString.QQ (r)
 
 experimentalResolver :: Schema IO
 experimentalResolver = schema queryType Nothing Nothing mempty
@@ -33,7 +33,7 @@ spec :: Spec
 spec =
     describe "Directive executor" $ do
         it "should be able to @skip fields" $ do
-            let sourceQuery = [r|
+            let sourceQuery = [gql|
               {
                 experimentalField @skip(if: true)
               }
@@ -43,7 +43,7 @@ spec =
             actual `shouldResolveTo` emptyObject
 
         it "should not skip fields if @skip is false" $ do
-            let sourceQuery = [r|
+            let sourceQuery = [gql|
               {
                 experimentalField @skip(if: false)
               }
@@ -56,7 +56,7 @@ spec =
             actual `shouldResolveTo` expected
 
         it "should skip fields if @include is false" $ do
-            let sourceQuery = [r|
+            let sourceQuery = [gql|
               {
                 experimentalField @include(if: false)
               }
@@ -66,7 +66,7 @@ spec =
             actual `shouldResolveTo` emptyObject
 
         it "should be able to @skip a fragment spread" $ do
-            let sourceQuery = [r|
+            let sourceQuery = [gql|
               {
                 ...experimentalFragment @skip(if: true)
               }
@@ -80,7 +80,7 @@ spec =
             actual `shouldResolveTo` emptyObject
 
         it "should be able to @skip an inline fragment" $ do
-            let sourceQuery = [r|
+            let sourceQuery = [gql|
               {
                 ... on Query @skip(if: true) {
                   experimentalField

tests/Test/FragmentSpec.hs

@@ -15,9 +15,9 @@ import Data.Text (Text)
 import Language.GraphQL
 import Language.GraphQL.Type
 import qualified Language.GraphQL.Type.Out as Out
+import Language.GraphQL.TH
 import Test.Hspec (Spec, describe, it)
 import Test.Hspec.GraphQL
-import Text.RawString.QQ (r)
 
 size :: (Text, Value)
 size = ("size", String "L")
@@ -34,16 +34,18 @@ garment typeName =
     )
 
 inlineQuery :: Text
-inlineQuery = [r|{
+inlineQuery = [gql|
-  garment {
+  {
-    ... on Hat {
+    garment {
-      circumference
+      ... on Hat {
-    }
+        circumference
-    ... on Shirt {
+      }
-      size
+      ... on Shirt {
+        size
+      }
     }
   }
-}|]
+|]
 
 shirtType :: Out.ObjectType IO
 shirtType = Out.ObjectType "Shirt" Nothing [] $ HashMap.fromList
@@ -106,12 +108,14 @@ spec = do
              in actual `shouldResolveTo` expected
 
         it "embeds inline fragments without type" $ do
-            let sourceQuery = [r|{
+            let sourceQuery = [gql|
-              circumference
+              {
-              ... {
+                circumference
-                size
+                ... {
+                  size
+                }
               }
-            }|]
+            |]
             actual <- graphql (toSchema "circumference" circumference) sourceQuery
             let expected = HashMap.singleton "data"
                     $ Aeson.object
@@ -121,16 +125,18 @@ spec = do
              in actual `shouldResolveTo` expected
 
         it "evaluates fragments on Query" $ do
-            let sourceQuery = [r|{
+            let sourceQuery = [gql|
-              ... {
+              {
-                size
+                ... {
+                  size
+                }
               }
-            }|]
+            |]
              in graphql (toSchema "size" size) `shouldResolve` sourceQuery
 
     describe "Fragment spread executor" $ do
         it "evaluates fragment spreads" $ do
-            let sourceQuery = [r|
+            let sourceQuery = [gql|
               {
                 ...circumferenceFragment
               }
@@ -148,7 +154,7 @@ spec = do
              in actual `shouldResolveTo` expected
 
         it "evaluates nested fragments" $ do
-            let sourceQuery = [r|
+            let sourceQuery = [gql|
               {
                 garment {
                   ...circumferenceFragment
@@ -174,7 +180,7 @@ spec = do
              in actual `shouldResolveTo` expected
 
         it "considers type condition" $ do
-            let sourceQuery = [r|
+            let sourceQuery = [gql|
               {
                 garment {
                   ...circumferenceFragment

tests/Test/RootOperationSpec.hs

@@ -12,7 +12,7 @@ import Data.Aeson ((.=), object)
 import qualified Data.HashMap.Strict as HashMap
 import Language.GraphQL
 import Test.Hspec (Spec, describe, it)
-import Text.RawString.QQ (r)
+import Language.GraphQL.TH
 import Language.GraphQL.Type
 import qualified Language.GraphQL.Type.Out as Out
 import Test.Hspec.GraphQL
@@ -42,7 +42,7 @@ spec :: Spec
 spec =
     describe "Root operation type" $ do
         it "returns objects from the root resolvers" $ do
-            let querySource = [r|
+            let querySource = [gql|
               {
                 garment {
                   circumference
@@ -59,7 +59,7 @@ spec =
             actual `shouldResolveTo` expected
 
         it "chooses Mutation" $ do
-            let querySource = [r|
+            let querySource = [gql|
               mutation {
                 incrementCircumference
               }