Add a release task

inside an input object for the role checking for unused and undefined
variables.

.gitea/workflows/build.yml

@@ -0,0 +1,52 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+    branches: [master]
+
+jobs:
+  audit:
+    runs-on: haskell
+    steps:
+      - name: Set up environment
+        run: |
+          apt-get update -y
+          apt-get upgrade -y
+          apt-get install -y nodejs pkg-config
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        run: |
+          cabal update
+          cabal install hlint "--constraint=hlint ==3.8"
+      - run: cabal exec hlint -- src tests
+
+  test:
+    runs-on: haskell
+    steps:
+      - name: Set up environment
+        run: |
+          apt-get update -y
+          apt-get upgrade -y
+          apt-get install -y nodejs pkg-config
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        run: cabal update
+      - name: Prepare system
+        run: cabal build graphql-test
+      - run: cabal test --test-show-details=streaming
+
+  doc:
+    runs-on: haskell
+    steps:
+      - name: Set up environment
+        run: |
+          apt-get update -y
+          apt-get upgrade -y
+          apt-get install -y nodejs pkg-config
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        run: cabal update
+      - run: cabal haddock --enable-documentation

.gitea/workflows/release.yml

@@ -0,0 +1,23 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - '**'
+
+jobs:
+  release:
+    runs-on: haskell
+    steps:
+      - name: Set up environment
+        run: |
+          apt-get update -y
+          apt-get upgrade -y
+          apt-get install -y nodejs pkg-config
+      - uses: actions/checkout@v4
+      - name: Upload a candidate
+        env:
+          HACKAGE_PASSWORD: ${{ secrets.HACKAGE_PASSWORD }}
+        run: |
+          cabal sdist
+          cabal upload --username belka --password ${HACKAGE_PASSWORD}

.github/workflows/haskell.yml

@@ -1,63 +0,0 @@
-name: Haskell CI
-
-on:
-  push: ~
-  pull_request:
-    branches: [master]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-haskell@v1
-      with:
-        enable-stack: true
-        stack-no-global: true
-        stack-version: latest
-
-    - name: Cache
-      uses: actions/cache@v2
-      with:
-        path: |
-          ~/.stack
-          stack.yaml.lock
-        key: ${{ runner.os }}-test-${{ hashFiles('**/stack.yaml') }}
-        restore-keys: ${{ runner.os }}-test-
-
-    - name: Install dependencies
-      run: stack --no-terminal test --only-snapshot
-    - name: Run tests
-      run: stack --no-terminal test --pedantic
-    - name: Build the documentation
-      run: |
-        stack --no-terminal ghc -- -Wall -Werror -fno-code docs/tutorial/tutorial.lhs
-        stack --no-terminal haddock --no-haddock-deps
-
-  lint:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-haskell@v1
-      with:
-        enable-stack: true
-        stack-no-global: true
-        stack-version: latest
-
-    - name: Cache
-      uses: actions/cache@v2
-      with:
-        path: |
-          ~/.stack
-          stack.yaml.lock
-        key: ${{ runner.os }}-lint-${{ hashFiles('**/stack.yaml') }}
-        restore-keys: ${{ runner.os }}-lint-
-
-    - name: Build HLint
-      run: stack --no-terminal build hlint
-    - name: Install HLint
-      run: stack --no-terminal install hlint
-    - name: Lint
-      run: stack --no-terminal exec hlint -- src tests docs

CHANGELOG.md

@@ -6,28 +6,219 @@ The format is based on
 and this project adheres to
 [Haskell Package Versioning Policy](https://pvp.haskell.org/).
 
+## [1.3.0.0] - 2024-05-01
+### Changed
+- Remove deprecated `runCollectErrs`, `Resolution`, `CollectErrsT` from the
+  `Error` module.
+
+## [1.2.0.3] - 2024-01-09
+### Fixed
+- Fix corrupted source distribution.
+
+## [1.2.0.2] - 2024-01-09
+### Fixed
+- `gql` removes not only leading `\n` but also `\r`.
+- Fix non nullable type string representation in executor error messages.
+- Fix input objects not being coerced to lists.
+- Fix used variables are not found in the properties of input objects.
+
+## [1.2.0.1] - 2023-04-25
+### Fixed
+- Support hspec 2.11.
+
+## [1.2.0.0] - 2023-02-28
+### Added
+- Schema printing.
+- `Semigroup` and `Monoid` instances for `AST.Document.Description`.
+- Support for vector 0.13.0.0 and transformers 0.6.1.0.
+
+### Fixed
+- Fix resolvers returning a list in the reverse order.
+
+### Removed
+- GHC 8 support.
+- Cabal -json flag.
+- `Test.Hspec.GraphQL`: moved to `graphql-spice` package.
+- CPP `ifdef WITH_JSON` blocks.
+
+## [1.1.0.0] - 2022-12-24
+### Changed
+- Removed deprecated `Language.GraphQL.Error` functions: `addErr`, `addErrMsg`,
+  `singleError`.
+- Deprecate `Resolution`, `CollectErrsT` and `runCollectErrs` in the `Error`
+  module. It was already noted in the documentation that these symbols are
+  deprecated, now a pragma is added.
+- `Language.GraphQL`: Added information about the *json* flag and switching to
+  *graphql-spice* for JSON support.
+
+### Added
+- Partial schema printing: operation type encoder.
+
+## [1.0.3.0] - 2022-03-27
+### Fixed
+- Index position in error path. (Index and Segment paths of a field have been
+  swapped).
+- Parsing empty list as an argument.
+
+### Added
+- quickCheck Parser test for arguments. Arbitrary instances for Language.GraphQL.AST.Document.
+- Enhanced query error messages. Add tests for these cases.
+- Allow version 2.0 of the text package.
+
+## [1.0.2.0] - 2021-12-26
+### Added
+- `Serialize` instance for `Type.Definition.Value`.
+- `VariableValue` instance for `Type.Definition.Value`.
+- `Json` build flag, enabled by default. JSON and Aeson support can be disabled
+  by disabling this flag.
+
+## [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`
+  and  `InlineFragment`. Thus validation rules can be defined more concise.
+- `AST.Document`: `Argument` and `Directive` contain token location.
+- `AST.Document.Argument` contains the `Value` wrapped in the `Node`.
+- `AST.Lexer.colon` and `AST.Lexer.at` ignore the result (it is always the
+- same).
+- `Validate.Validation`: `Validation.rules` was removed. `Validation.rules`
+  contained the list of rules, but the executed rules shouldn't know about other
+  rules. `rules` was a part of the `Validation` context to pass it easier
+  around, but since the rules are traversed once now and applied to all nodes in
+  the tree at the beginning, it isn't required anymore.
+- `Validate.Validation.Error`: `path` is removed since it isn't possible to get
+  the path without executing the query.
+- `Error.Error`: `path` added. It is currently always empty.
+- `Validate.Validation.Path` was moved to `Error`.
+- `Type.Schema.Schema`: data constructor is hidden, fields are accessible with
+  freestanding functions: `query`, `mutation`, `subscription`, `directives` and
+  `types`.
+
+### Added
+- `Validate.Validation.Rule` constructors:
+  - `SelectionRule`
+  - `FragmentRule`
+  - `FragmentSpreadRule`
+  - `ArgumentsRule`
+  - `DirectivesRule`
+  - `VariablesRule`
+  - `FieldRule`
+- `Validate.Rules`:
+  - `fragmentsOnCompositeTypesRule`
+  - `fragmentSpreadTargetDefinedRule`
+  - `fragmentSpreadTypeExistenceRule`
+  - `noUnusedFragmentsRule`
+  - `noFragmentCyclesRule`
+  - `uniqueArgumentNamesRule`
+  - `uniqueDirectiveNamesRule`
+  - `uniqueVariableNamesRule`
+  - `variablesAreInputTypesRule`
+  - `noUndefinedVariablesRule`
+  - `noUndefinedVariablesRule`
+  - `noUnusedVariablesRule`
+  - `uniqueInputFieldNamesRule`
+  - `fieldsOnCorrectTypeRule`
+  - `scalarLeafsRule`
+  - `knownArgumentNamesRule`
+  - `knownDirectiveNamesRule`
+  - `directivesInValidLocationsRule`
+  - `providedRequiredArgumentsRule`
+  - `providedRequiredInputFieldsRule`
+- `AST.Document.Field`.
+- `AST.Document.FragmentSpread`.
+- `AST.Document.InlineFragment`.
+- `AST.Document.Node`.
+- `Type.In.Arguments`: Type alias for an argument map.
+- `Type.Schema.Directive` and `Type.Schema.Directives` are directive definition
+  representation.
+- `Type.Schema.schema`: Schema constructor.
+
+### Fixed
+- Collecting existing types from the schema considers subscriptions.
+
+### Removed
+- `AST.Document.Alias`. Use `AST.Document.Name` instead.
+
 ## [0.10.0.0] - 2020-08-29
-## Changed
+### Changed
 - `Test.Hspec.GraphQL.*`: replace `IO` in the resolver with any `MonadCatch`.
 - The `Location` argument of `AST.Document.Definition.ExecutableDefinition` was
   moved to `OperationDefinition` and `FragmentDefinition` since these are the
   actual elements that have a location in the document.
 - `Validate.Rules` get the whole validation context (AST and schema).
 
-## Added
+### Added
 - `Validate.Validation` contains data structures and functions used by the
   validator and concretet rules.
 - `Validate.Rules`: operation validation rules.
 
 ## [0.9.0.0] - 2020-07-24
-## Fixed
+### Fixed
 - Location of a parse error is returned in a singleton array with key
   `locations`.
 - Parsing comments in the front of definitions.
 - Some missing labels were added to the parsers, some labels were fixed to
-  refer to the AST nodes being parsed. 
+  refer to the AST nodes being parsed.
 
-## Added
+### Added
 - `AST` reexports `AST.Parser`.
 - `AST.Document.Location` is a token location as a line and column pair.
 - `Execute` reexports `Execute.Coerce`.
@@ -43,7 +234,7 @@ and this project adheres to
 - `Test.Hspec.GraphQL` contains some test helpers.
 - `Validate` contains the validator and standard rules.
 
-## Changed
+### Changed
 - `Type.Out.Resolver`: Interface fields don't have resolvers, object fields
   have value resolvers, root subscription type resolvers need an additional
   resolver that creates an event stream. `Resolver` represents these differences
@@ -67,7 +258,7 @@ and this project adheres to
 - The constraint of the base monad was changed to `MonadCatch` (and it implies
   `MonadThrow`).
 
-## Removed
+### Removed
 - `Trans.ActionT` is an unneeded layer of complexity. `Type.Out.Resolver`
   represents possible resolver configurations.
 - `Execute.executeWithName`. `Execute.execute` takes the operation name and
@@ -229,7 +420,6 @@ and this project adheres to
 - `Language.GraphQL.Schema`: `enum`, `enumA`, `wrappedEnum` and `wrappedEnumA`.
   Use `scalar`, `scalarA`, `wrappedScalar` and `wrappedScalarA` instead.
 
-
 ## [0.5.1.0] - 2019-10-22
 ### Deprecated
 - `Language.GraphQL.AST.Arguments`. Use `[Language.GraphQL.AST.Argument]`
@@ -334,16 +524,28 @@ and this project adheres to
 ### Added
 - Data types for the GraphQL language.
 
-[0.10.0.0]: https://github.com/caraus-ecms/graphql/compare/v0.9.0.0...v0.10.0.0
-[0.9.0.0]: https://github.com/caraus-ecms/graphql/compare/v0.8.0.0...v0.9.0.0
-[0.8.0.0]: https://github.com/caraus-ecms/graphql/compare/v0.7.0.0...v0.8.0.0
-[0.7.0.0]: https://github.com/caraus-ecms/graphql/compare/v0.6.1.0...v0.7.0.0
-[0.6.1.0]: https://github.com/caraus-ecms/graphql/compare/v0.6.0.0...v0.6.1.0
-[0.6.0.0]: https://github.com/caraus-ecms/graphql/compare/v0.5.1.0...v0.6.0.0
-[0.5.1.0]: https://github.com/caraus-ecms/graphql/compare/v0.5.0.1...v0.5.1.0
-[0.5.0.1]: https://github.com/caraus-ecms/graphql/compare/v0.5.0.0...v0.5.0.1
-[0.5.0.0]: https://github.com/caraus-ecms/graphql/compare/v0.4.0.0...v0.5.0.0
-[0.4.0.0]: https://github.com/caraus-ecms/graphql/compare/v0.3...v0.4.0.0
-[0.3]: https://github.com/caraus-ecms/graphql/compare/v0.2.1...v0.3
-[0.2.1]: https://github.com/caraus-ecms/graphql/compare/v0.2...v0.2.1
-[0.2]: https://github.com/caraus-ecms/graphql/compare/v0.1...v0.2
+[1.3.0.0]: https://git.caraus.tech/OSS/graphql/compare/v1.2.0.3...v1.3.0.0
+[1.2.0.3]: https://git.caraus.tech/OSS/graphql/compare/v1.2.0.2...v1.2.0.3
+[1.2.0.2]: https://git.caraus.tech/OSS/graphql/compare/v1.2.0.1...v1.2.0.2
+[1.2.0.1]: https://git.caraus.tech/OSS/graphql/compare/v1.2.0.0...v1.2.0.1
+[1.2.0.0]: https://git.caraus.tech/OSS/graphql/compare/v1.1.0.0...v1.2.0.0
+[1.1.0.0]: https://git.caraus.tech/OSS/graphql/compare/v1.0.3.0...v1.1.0.0
+[1.0.3.0]: https://git.caraus.tech/OSS/graphql/compare/v1.0.2.0...v1.0.3.0
+[1.0.2.0]: https://git.caraus.tech/OSS/graphql/compare/v1.0.1.0...v1.0.2.0
+[1.0.1.0]: https://git.caraus.tech/OSS/graphql/compare/v1.0.0.0...v1.0.1.0
+[1.0.0.0]: https://git.caraus.tech/OSS/graphql/compare/v0.11.1.0...v1.0.0.0
+[0.11.1.0]: https://git.caraus.tech/OSS/graphql/compare/v0.11.0.0...v0.11.1.0
+[0.11.0.0]: https://git.caraus.tech/OSS/graphql/compare/v0.10.0.0...v0.11.0.0
+[0.10.0.0]: https://git.caraus.tech/OSS/graphql/compare/v0.9.0.0...v0.10.0.0
+[0.9.0.0]: https://git.caraus.tech/OSS/graphql/compare/v0.8.0.0...v0.9.0.0
+[0.8.0.0]: https://git.caraus.tech/OSS/graphql/compare/v0.7.0.0...v0.8.0.0
+[0.7.0.0]: https://git.caraus.tech/OSS/graphql/compare/v0.6.1.0...v0.7.0.0
+[0.6.1.0]: https://git.caraus.tech/OSS/graphql/compare/v0.6.0.0...v0.6.1.0
+[0.6.0.0]: https://git.caraus.tech/OSS/graphql/compare/v0.5.1.0...v0.6.0.0
+[0.5.1.0]: https://git.caraus.tech/OSS/graphql/compare/v0.5.0.1...v0.5.1.0
+[0.5.0.1]: https://git.caraus.tech/OSS/graphql/compare/v0.5.0.0...v0.5.0.1
+[0.5.0.0]: https://git.caraus.tech/OSS/graphql/compare/v0.4.0.0...v0.5.0.0
+[0.4.0.0]: https://git.caraus.tech/OSS/graphql/compare/v0.3...v0.4.0.0
+[0.3]: https://git.caraus.tech/OSS/graphql/compare/v0.2.1...v0.3
+[0.2.1]: https://git.caraus.tech/OSS/graphql/compare/v0.2...v0.2.1
+[0.2]: https://git.caraus.tech/OSS/graphql/compare/v0.1...v0.2

CONTRIBUTING.md

@@ -1,31 +0,0 @@
-# Contributing guidelines
-
-## Testing
-
-To ensure all code changes adhere to existing code quality standards, some
-automatic checks can be run locally.
-
-Ensure that the code builds without warnings and passes the tests:
-
-```sh
-stack test --pedantic
-```
-
-And also run the linter on your code:
-
-```sh
-stack build hlint
-stack exec hlint -- src tests
-```
-
-Build the documentation and check if you get any warnings:
-
-```sh
-stack haddock
-```
-
-Validate that literate Haskell (tutorials) files compile without any warnings:
-
-```sh
-stack ghc -- -Wall -fno-code docs/tutorial/*.lhs
-```

LICENSE.MPL

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  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 http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

README.md

@@ -1,148 +1,12 @@
 # GraphQL implementation in Haskell
 
-[![Hackage Version](https://img.shields.io/hackage/v/graphql.svg)](https://hackage.haskell.org/package/graphql)
-[![Build Status](https://github.com/caraus-ecms/graphql/workflows/Haskell%20CI/badge.svg)](https://github.com/caraus-ecms/graphql/actions?query=workflow%3A%22Haskell+CI%22)
-[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](https://raw.githubusercontent.com/caraus-ecms/graphql/master/LICENSE)
-[![Simple Haskell](https://www.simplehaskell.org/badges/badge.svg)](https://www.simplehaskell.org)
+See https://git.caraus.tech/OSS/graphql.
 
-This implementation is relatively low-level by design, it doesn't provide any
-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
-
-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 marked as
-"[not implemented](https://github.com/caraus-ecms/graphql/labels/not%20implemented)".
-
-## Documentation
+Report issues on the
+[bug tracker](https://git.caraus.tech/OSS/graphql/issues).
 
 API documentation is available through
 [Hackage](https://hackage.haskell.org/package/graphql).
 
-You'll also find a small tutorial with some examples under
-[docs/tutorial](https://github.com/caraus-ecms/graphql/tree/master/docs/tutorial).
-
-### Getting started
-
-We start with a simple GraphQL API that provides us with some famous and less
-famous cites.
-
-```graphql
-"""
-Root Query type.
-"""
-type Query {
-  """
-  Provides a cite.
-  """
-  cite: String!
-}
-```
-
-This is called a GraphQL schema, it defines all queries supported by the API.
-`Query` is the root query type. Every GraphQL API should define a query type.
-
-`Query` has a single field `cite` that returns a `String`. The `!` after the
-type denotes that the returned value cannot be `Null`. GraphQL fields are
-nullable by default.
-
-To be able to work with this schema, we are going to implement it in Haskell.
-
-```haskell
-{-# LANGUAGE OverloadedStrings #-}
-
-import Control.Exception (SomeException)
-import qualified Data.Aeson as Aeson
-import qualified Data.ByteString.Lazy.Char8 as ByteString.Lazy.Char8
-import qualified Data.HashMap.Strict as HashMap
-import Language.GraphQL
-import Language.GraphQL.Type
-import qualified Language.GraphQL.Type.Out as Out
-
--- GraphQL supports 3 kinds of operations: queries, mutations and subscriptions.
--- Our first schema supports only queries.
-schema :: Schema IO
-schema = Schema
-    { query = queryType, mutation = Nothing, subscription = Nothing }
-
--- GraphQL distinguishes between input and output types. Input types are field
--- argument types and they are defined in Language.GraphQL.Type.In. Output types
--- are result types, they are defined in Language.GraphQL.Type.Out. Root types
--- are always object types.
---
--- Here we define a type "Query". The second argument is an optional
--- description, the third one is the list of interfaces implemented by the
--- object type. The last argument is a field map. Keys are field names, values
--- are field definitions and resolvers. Resolvers are the functions, where the
--- actual logic lives, they return values for the respective fields.
-queryType :: Out.ObjectType IO
-queryType = Out.ObjectType "Query" (Just "Root Query type.") []
-    $ HashMap.singleton "cite" citeResolver
-  where
-    -- 'ValueResolver' is a 'Resolver' data constructor, it combines a field
-    -- definition with its resolver function. This function resolves a value for
-    -- a field (as opposed to the 'EventStreamResolver' used by subscriptions).
-    -- Our resolver just returns a constant value.
-    citeResolver = ValueResolver citeField
-        $ pure "Piscis primum a capite foetat"
-    -- The first argument is an optional field description. The second one is
-    -- the field type and the third one is for arguments (we have none in this
-    -- example).
-    --
-    -- GraphQL has named and wrapping types. String is a scalar, named type.
-    -- Named types are nullable by default. To make our "cite" field
-    -- non-nullable, we wrap it in the wrapping type, Non-Null.
-    citeField = Out.Field
-        (Just "Provides a cite.") (Out.NonNullScalarType string) HashMap.empty
-
--- Now we can execute a query. Since our schema defines only one field,
--- everything we can do is to ask to resolve it and give back the result.
--- Since subscriptions don't return plain values, the 'graphql' function returns
--- an 'Either'. 'Left' is for subscriptions, 'Right' is for queries and
--- mutations.
-main :: IO ()
-main = do
-    Right result <- graphql schema "{ cite }"
-    ByteString.Lazy.Char8.putStrLn $ Aeson.encode result
-```
-
-Executing this query produces the following JSON:
-
-```json
-{
-  "data": {
-    "cite": "Piscis primum a capite foetat"
-  }
-}
-```
-
-## Further information
-
-- [Contributing guidelines](CONTRIBUTING.md).
-- [Changelog](CHANGELOG.md) – this one contains the most recent changes; 
-  individual changelogs for specific versions can be found on
-  [Hackage](https://hackage.haskell.org/package/graphql).
-
-## Contact
-
-Suggestions, contributions and bug reports are welcome.
-
-Should you have questions on usage, please open an issue and ask – this helps
-to write useful documentation.
-
-Feel free to contact on Slack in [#haskell on
-GraphQL](https://graphql.slack.com/messages/haskell/). You can obtain an
-invitation [here](https://graphql-slack.herokuapp.com/).
+Further documentation will be made available in the
+[Wiki](https://git.caraus.tech/OSS/graphql/wiki).

docs/tutorial/tutorial.lhs

@@ -1,152 +0,0 @@
----
-title: GraphQL Haskell Tutorial
----
-
-
-== Getting started ==
-
-Welcome to GraphQL!
-
-We have written a small tutorial to help you (and ourselves) understand the
-graphql package.
-
-Since this file is a literate haskell file, we start by importing some
-dependencies.
-
-> {-# LANGUAGE OverloadedStrings #-}
-> module Main where
->
-> import Control.Monad.IO.Class (liftIO)
-> import Data.Aeson (encode)
-> import Data.ByteString.Lazy.Char8 (putStrLn)
-> import qualified Data.HashMap.Strict as HashMap
-> import Data.Text (Text)
-> import qualified Data.Text as Text
-> import Data.Time (getCurrentTime)
->
-> import Language.GraphQL
-> import Language.GraphQL.Type
-> import qualified Language.GraphQL.Type.Out as Out
->
-> import Prelude hiding (putStrLn)
-
-
-=== First example ===
-
-Now, as our first example, we are going to look at the example from
-[graphql.js](https://github.com/graphql/graphql-js).
-
-First we build a GraphQL schema.
-
-> schema1 :: Schema IO
-> schema1 = Schema
->   { query = queryType , mutation = Nothing , subscription = Nothing }
->
-> queryType :: ObjectType IO
-> queryType = ObjectType "Query" Nothing []
->   $ HashMap.singleton "hello"
->   $ ValueResolver helloField hello
->
-> helloField :: Field IO
-> helloField = Field Nothing (Out.NamedScalarType string) mempty
->
-> hello :: Resolve IO
-> hello = pure $ String "it's me"
-
-This defines a simple schema with one type and one field, that resolves to a
-fixed value.
-
-Next we define our query.
-
-> query1 :: Text
-> query1 = "{ hello }"
-
-To run the query, we call the `graphql` with the schema and the query.
-
-> main1 :: IO ()
-> main1 = graphql schema1 query1
->   >>= either (const $ pure ()) (putStrLn . encode)
-
-This runs the query by fetching the one field defined, returning
-
-```{"data" : {"hello":"it's me"}}```
-
-
-=== Monadic actions ===
-
-For this example, we're going to be using time.
-
-> schema2 :: Schema IO
-> schema2 = Schema
->   { query = queryType2, mutation = Nothing, subscription = Nothing }
->
-> queryType2 :: ObjectType IO
-> queryType2 = ObjectType "Query" Nothing []
->   $ HashMap.singleton "time"
->   $ ValueResolver timeField time
->
-> timeField :: Field IO
-> timeField = Field Nothing (Out.NamedScalarType string) mempty
->
-> time :: Resolve IO
-> time = do
->   t <- liftIO getCurrentTime
->   pure $ String $ Text.pack $ show t
-
-This defines a simple schema with one type and one field, which resolves to the
-current time.
-
-Next we define our query.
-
-> query2 :: Text
-> query2 = "{ time }"
->
-> main2 :: IO ()
-> main2 = graphql schema2 query2
->   >>= either (const $ pure ()) (putStrLn . encode)
-
-This runs the query, returning the current time
-
-```{"data": {"time":"2016-03-08 23:28:14.546899 UTC"}}```
-
-
-=== Combining resolvers ===
-
-Now that we have two resolvers, we can define a schema which uses them both.
-
-> schema3 :: Schema IO
-> schema3 = Schema
->   { query = queryType3, mutation = Nothing, subscription = Nothing }
->
-> queryType3 :: ObjectType IO
-> queryType3 = ObjectType "Query" Nothing [] $ HashMap.fromList
->   [ ("hello", ValueResolver helloField hello)
->   , ("time", ValueResolver timeField time)
->   ]
->
-> query3 :: Text
-> query3 = "query timeAndHello { time hello }"
->
-> main3 :: IO ()
-> main3 = graphql schema3 query3
->   >>= either (const $ pure ()) (putStrLn . encode)
-
-This queries for both time and hello, returning
-
-```{ "data": {"hello":"it's me","time":"2016-03-08 23:29:11.62108 UTC"}}```
-
-Notice that we can name our queries, as we did with `timeAndHello`. Since we
-have only been using single queries, we can use the shorthand `{ time hello }`,
-as we have been doing in the previous examples.
-
-In GraphQL there can only be one operation per query.
-
-
-== Further examples ==
-
-More examples on queries and a more complex schema can be found in the test
-directory, in the [Test.StarWars](../../tests/Test/StarWars) module. This
-includes a more complex schema, and more complex queries.
-
-> main :: IO ()
-> main = main1 >> main2 >> main3

graphql.cabal

@@ -1,119 +1,111 @@
-cabal-version: 1.12
-
--- This file has been generated from package.yaml by hpack version 0.33.0.
---
--- see: https://github.com/sol/hpack
---
--- hash: 3ef060c57424074b84204bae61ee0a63e3470a7a060c45a977ff2bcbe4df8775
+cabal-version: 2.4
 
 name:           graphql
-version:        0.10.0.0
+version:        1.3.0.0
 synopsis:       Haskell GraphQL implementation
-description:    This package provides a rudimentary parser for the <https://graphql.github.io/graphql-spec/June2018/ GraphQL> language.
+description:    Haskell <https://spec.graphql.org/June2018/ GraphQL> implementation.
 category:       Language
-homepage:       https://github.com/caraus-ecms/graphql#readme
-bug-reports:    https://github.com/caraus-ecms/graphql/issues
+homepage:       https://git.caraus.tech/OSS/graphql
+bug-reports:    https://git.caraus.tech/OSS/graphql/issues
 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-2024 Eugen Wissner,
                 (c) 2015-2017 J. Daniel Navarro
-license:        BSD3
-license-file:   LICENSE
+license:        MPL-2.0 AND BSD-3-Clause
+license-files:  LICENSE,
+                LICENSE.MPL
 build-type:     Simple
 extra-source-files:
-    CHANGELOG.md
-    CONTRIBUTING.md
-    LICENSE
-    README.md
-    docs/tutorial/tutorial.lhs
+  CHANGELOG.md
+  README.md
+tested-with:
+  GHC == 9.4.7,
+  GHC == 9.6.3
 
 source-repository head
   type: git
-  location: https://github.com/caraus-ecms/graphql
+  location: https://git.caraus.tech/OSS/graphql.git
 
 library
   exposed-modules:
-      Language.GraphQL
-      Language.GraphQL.AST
-      Language.GraphQL.AST.DirectiveLocation
-      Language.GraphQL.AST.Document
-      Language.GraphQL.AST.Encoder
-      Language.GraphQL.AST.Lexer
-      Language.GraphQL.AST.Parser
-      Language.GraphQL.Error
-      Language.GraphQL.Execute
-      Language.GraphQL.Execute.Coerce
-      Language.GraphQL.Type
-      Language.GraphQL.Type.In
-      Language.GraphQL.Type.Out
-      Language.GraphQL.Type.Schema
-      Language.GraphQL.Validate
-      Language.GraphQL.Validate.Validation
-      Test.Hspec.GraphQL
+    Language.GraphQL
+    Language.GraphQL.AST
+    Language.GraphQL.AST.DirectiveLocation
+    Language.GraphQL.AST.Document
+    Language.GraphQL.AST.Encoder
+    Language.GraphQL.AST.Lexer
+    Language.GraphQL.AST.Parser
+    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
+    Language.GraphQL.Type.Schema
+    Language.GraphQL.Validate
+    Language.GraphQL.Validate.Validation
   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
+    Language.GraphQL.Execute.Transform
+    Language.GraphQL.Type.Definition
+    Language.GraphQL.Type.Internal
+    Language.GraphQL.Validate.Rules
   hs-source-dirs:
-      src
+    src
+  ghc-options: -Wall
+
   build-depends:
-      aeson
-    , base >=4.7 && <5
-    , conduit
-    , containers
-    , exceptions
-    , hspec-expectations
-    , megaparsec
-    , parser-combinators
-    , scientific
-    , text
-    , transformers
-    , unordered-containers
+    base >= 4.7 && < 5,
+    conduit ^>= 1.3.4,
+    containers >= 0.6 && < 0.8,
+    exceptions ^>= 0.10.4,
+    megaparsec >= 9.0 && < 10,
+    parser-combinators >= 1.3 && < 2,
+    template-haskell >= 2.16 && < 3,
+    text >= 1.2 && < 3,
+    transformers >= 0.5.6 && < 0.7,
+    unordered-containers ^>= 0.2.14,
+    vector >= 0.12 && < 0.14
+
   default-language: Haskell2010
 
-test-suite tasty
+test-suite graphql-test
   type: exitcode-stdio-1.0
   main-is: Spec.hs
   other-modules:
-      Language.GraphQL.AST.EncoderSpec
-      Language.GraphQL.AST.LexerSpec
-      Language.GraphQL.AST.ParserSpec
-      Language.GraphQL.ErrorSpec
-      Language.GraphQL.Execute.CoerceSpec
-      Language.GraphQL.ExecuteSpec
-      Language.GraphQL.Type.OutSpec
-      Language.GraphQL.ValidateSpec
-      Test.DirectiveSpec
-      Test.FragmentSpec
-      Test.RootOperationSpec
-      Test.StarWars.Data
-      Test.StarWars.QuerySpec
-      Test.StarWars.Schema
-      Paths_graphql
+    Language.GraphQL.AST.DocumentSpec
+    Language.GraphQL.AST.EncoderSpec
+    Language.GraphQL.AST.LexerSpec
+    Language.GraphQL.AST.ParserSpec
+    Language.GraphQL.AST.Arbitrary
+    Language.GraphQL.ErrorSpec
+    Language.GraphQL.Execute.CoerceSpec
+    Language.GraphQL.Execute.OrderedMapSpec
+    Language.GraphQL.ExecuteSpec
+    Language.GraphQL.Type.OutSpec
+    Language.GraphQL.Validate.RulesSpec
+    Schemas.HeroSchema
   hs-source-dirs:
-      tests
-  ghc-options: -threaded -rtsopts -with-rtsopts=-N
+    tests
+  ghc-options: -threaded -rtsopts -with-rtsopts=-N -Wall
+
   build-depends:
-      QuickCheck
-    , aeson
-    , base >=4.7 && <5
-    , conduit
-    , containers
-    , exceptions
-    , graphql
-    , hspec
-    , hspec-expectations
-    , hspec-megaparsec
-    , megaparsec
-    , parser-combinators
-    , raw-strings-qq
-    , scientific
-    , text
-    , transformers
-    , unordered-containers
+    QuickCheck >= 2.14 && < 2.16,
+    base,
+    conduit,
+    exceptions,
+    graphql,
+    hspec >= 2.10.9 && < 2.12,
+    hspec-expectations ^>= 0.8.2,
+    hspec-megaparsec ^>= 2.2.0,
+    megaparsec,
+    text,
+    unordered-containers,
+    containers,
+    vector
+  build-tool-depends:
+    hspec-discover:hspec-discover
   default-language: Haskell2010

package.yaml

@@ -1,62 +0,0 @@
-name:                graphql
-version:             0.10.0.0
-synopsis:            Haskell GraphQL implementation
-description:
-  This package provides a rudimentary parser for the
-  <https://graphql.github.io/graphql-spec/June2018/ GraphQL> language.
-maintainer:          belka@caraus.de
-github:              caraus-ecms/graphql
-category:            Language
-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>
-
-extra-source-files:
-- CHANGELOG.md
-- CONTRIBUTING.md
-- LICENSE
-- README.md
-- docs/tutorial/tutorial.lhs
-
-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:
-  tasty:
-    main: Spec.hs
-    source-dirs: tests
-    ghc-options:
-    - -threaded
-    - -rtsopts
-    - -with-rtsopts=-N
-    dependencies:
-    - graphql
-    - hspec
-    - hspec-megaparsec
-    - QuickCheck
-    - raw-strings-qq

src/Language/GraphQL.hs

@@ -1,79 +1,46 @@
-{-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
 
 -- | This module provides the functions to parse and execute @GraphQL@ queries.
 module Language.GraphQL
     ( graphql
-    , graphqlSubs
     ) where
 
 import Control.Monad.Catch (MonadCatch)
-import qualified Data.Aeson as Aeson
-import qualified Data.Aeson.Types as Aeson
-import qualified Data.HashMap.Strict as HashMap
+import Data.HashMap.Strict (HashMap)
 import qualified Data.Sequence as Seq
 import Data.Text (Text)
-import Language.GraphQL.AST
+import qualified Data.Text as Text
+import qualified Language.GraphQL.AST as Full
 import Language.GraphQL.Error
 import Language.GraphQL.Execute
 import qualified Language.GraphQL.Validate as Validate
-import Language.GraphQL.Type.Schema
+import Language.GraphQL.Type.Schema (Schema)
+import Prelude hiding (null)
 import Text.Megaparsec (parse)
 
 -- | If the text parses correctly as a @GraphQL@ query the query is
 -- executed using the given 'Schema'.
-graphql :: MonadCatch m
-    => Schema m -- ^ Resolvers.
-    -> Text -- ^ Text representing a @GraphQL@ request document.
-    -> m (Either (ResponseEventStream m Aeson.Value) Aeson.Object) -- ^ Response.
-graphql schema = graphqlSubs schema mempty mempty
-
--- | If the text parses correctly as a @GraphQL@ query the substitution is
--- applied to the query and the query is then executed using to the given
--- 'Schema'.
-graphqlSubs :: MonadCatch m
+--
+-- An operation name can be given if the document contains multiple operations.
+graphql :: (MonadCatch m, VariableValue a, Serialize b)
     => Schema m -- ^ Resolvers.
     -> Maybe Text -- ^ Operation name.
-    -> Aeson.Object -- ^ Variable substitution function.
+    -> HashMap Full.Name a -- ^ Variable substitution function.
     -> Text -- ^ Text representing a @GraphQL@ request document.
-    -> m (Either (ResponseEventStream m Aeson.Value) Aeson.Object) -- ^ Response.
-graphqlSubs schema operationName variableValues document' =
-    case parse document "" document' of
-        Left errorBundle -> pure . formatResponse <$> parseError errorBundle
+    -> m (Either (ResponseEventStream m b) (Response b)) -- ^ Response.
+graphql schema operationName variableValues document' =
+    case parse Full.document "" document' of
+        Left errorBundle -> pure  <$> parseError errorBundle
         Right parsed ->
             case validate parsed of
-                Seq.Empty -> fmap formatResponse
-                    <$> execute schema operationName variableValues parsed
+                Seq.Empty -> execute schema operationName variableValues parsed
                 errors -> pure $ pure
-                    $ HashMap.singleton "errors"
-                    $ Aeson.toJSON
+                    $ Response null
                     $ fromValidationError <$> errors
   where
     validate = Validate.document schema Validate.specifiedRules
-    formatResponse (Response data'' Seq.Empty) = HashMap.singleton "data" data''
-    formatResponse (Response data'' errors') = HashMap.fromList
-        [ ("data", data'')
-        , ("errors", Aeson.toJSON $ fromError <$> errors')
-        ]
-    fromError Error{ locations = [], ..} =
-        Aeson.object [("message", Aeson.toJSON message)]
-    fromError Error{..} = Aeson.object
-        [ ("message", Aeson.toJSON message)
-        , ("locations", Aeson.listValue fromLocation locations)
-        ]
-    fromValidationError Validate.Error{..}
-        | [] <- path = Aeson.object
-            [ ("message", Aeson.toJSON message)
-            , ("locations", Aeson.listValue fromLocation locations)
-            ]
-        | otherwise = Aeson.object
-            [ ("message", Aeson.toJSON message)
-            , ("locations", Aeson.listValue fromLocation locations)
-            , ("path", Aeson.listValue fromPath path)
-            ]
-    fromPath (Validate.Segment segment) = Aeson.String segment
-    fromPath (Validate.Index index) = Aeson.toJSON index
-    fromLocation Location{..} = Aeson.object
-        [ ("line", Aeson.toJSON line)
-        , ("column", Aeson.toJSON column)
-        ]
+    fromValidationError Validate.Error{..} = Error
+        { message = Text.pack message
+        , locations = locations
+        , path = []
+        }

src/Language/GraphQL/AST.hs

@@ -1,6 +1,4 @@
-{- 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 #-}
 
 -- | Target AST for parser.
 module Language.GraphQL.AST

src/Language/GraphQL/AST/DirectiveLocation.hs

@@ -1,6 +1,4 @@
-{- 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. 
 -- This module describes locations in a document where directives can appear.
@@ -16,7 +14,13 @@ module Language.GraphQL.AST.DirectiveLocation
 data DirectiveLocation
     = ExecutableDirectiveLocation ExecutableDirectiveLocation
     | TypeSystemDirectiveLocation TypeSystemDirectiveLocation
-    deriving (Eq, Show)
+    deriving Eq
+
+instance Show DirectiveLocation where
+    show (ExecutableDirectiveLocation directiveLocation) =
+        show directiveLocation
+    show (TypeSystemDirectiveLocation directiveLocation) =
+        show directiveLocation
 
 -- | Where directives can appear in an executable definition, like a query.
 data ExecutableDirectiveLocation
@@ -27,7 +31,16 @@ data ExecutableDirectiveLocation
     | FragmentDefinition
     | FragmentSpread
     | InlineFragment
-    deriving (Eq, Show)
+    deriving Eq
+
+instance Show ExecutableDirectiveLocation where
+    show Query = "QUERY"
+    show Mutation = "MUTATION"
+    show Subscription = "SUBSCRIPTION"
+    show Field = "FIELD"
+    show FragmentDefinition = "FRAGMENT_DEFINITION"
+    show FragmentSpread = "FRAGMENT_SPREAD"
+    show InlineFragment = "INLINE_FRAGMENT"
 
 -- | Where directives can appear in a type system definition.
 data TypeSystemDirectiveLocation
@@ -42,4 +55,17 @@ data TypeSystemDirectiveLocation
     | EnumValue
     | InputObject
     | InputFieldDefinition
-    deriving (Eq, Show)
+    deriving Eq
+
+instance Show TypeSystemDirectiveLocation where
+    show Schema = "SCHEMA"
+    show Scalar = "SCALAR"
+    show Object = "OBJECT"
+    show FieldDefinition = "FIELD_DEFINITION"
+    show ArgumentDefinition = "ARGUMENT_DEFINITION"
+    show Interface = "INTERFACE"
+    show Union = "UNION"
+    show Enum = "ENUM"
+    show EnumValue = "ENUM_VALUE"
+    show InputObject = "INPUT_OBJECT"
+    show InputFieldDefinition = "INPUT_FIELD_DEFINITION"

src/Language/GraphQL/AST/Document.hs

@@ -1,12 +1,16 @@
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE ExplicitForAll #-}
+{-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE Safe #-}
 
 -- | This module defines an abstract syntax tree for the @GraphQL@ language. It
 -- follows closely the structure given in the specification. Please refer to
 -- <https://facebook.github.io/graphql/ Facebook's GraphQL Specification>.
 -- for more information.
 module Language.GraphQL.AST.Document
-    ( Alias
-    , Argument(..)
+    ( Argument(..)
     , ArgumentsDefinition(..)
     , ConstValue(..)
     , Definition(..)
@@ -15,13 +19,17 @@ module Language.GraphQL.AST.Document
     , Document
     , EnumValueDefinition(..)
     , ExecutableDefinition(..)
+    , Field(..)
     , FieldDefinition(..)
     , FragmentDefinition(..)
+    , FragmentSpread(..)
     , ImplementsInterfaces(..)
+    , InlineFragment(..)
     , InputValueDefinition(..)
     , Location(..)
     , Name
     , NamedType
+    , Node(..)
     , NonNullType(..)
     , ObjectField(..)
     , OperationDefinition(..)
@@ -40,14 +48,20 @@ module Language.GraphQL.AST.Document
     , UnionMemberTypes(..)
     , Value(..)
     , VariableDefinition(..)
+    , escape
+    , showVariableName
+    , showVariable
     ) 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
+import Language.GraphQL.AST.DirectiveLocation (DirectiveLocation)
 
 -- * Language
 
@@ -68,6 +82,18 @@ instance Ord Location where
         | thisLine > thatLine = GT
         | otherwise = compare thisColumn thatColumn
 
+-- | Contains some tree node with a location.
+data Node a = Node
+    { node :: a
+    , location :: Location
+    } 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
+
 -- ** Document
 
 -- | GraphQL document.
@@ -116,10 +142,15 @@ type SelectionSet = NonEmpty Selection
 -- | Field selection.
 type SelectionSetOpt = [Selection]
 
--- | Selection is a single entry in a selection set. It can be a single field,
--- fragment spread or inline fragment.
---
--- The only required property of a field is its name. Optionally it can also
+-- | Selection is a single entry in a selection set. It can be a single 'Field',
+-- 'FragmentSpread' or an 'InlineFragment'.
+data Selection
+    = FieldSelection Field
+    | FragmentSpreadSelection FragmentSpread
+    | InlineFragmentSelection InlineFragment
+    deriving (Eq, Show)
+
+-- | The only required property of a field is its name. Optionally it can also
 -- have an alias, arguments, directives and a list of subfields.
 --
 -- In the following query "user" is a field with two subfields, "id" and "name":
@@ -132,8 +163,27 @@ type SelectionSetOpt = [Selection]
 --   }
 -- }
 -- @
+data Field =
+    Field (Maybe Name) Name [Argument] [Directive] SelectionSetOpt Location
+    deriving (Eq, Show)
+
+-- | Inline fragments don't have any name and the type condition ("on UserType")
+-- is optional.
 --
--- A fragment spread refers to a fragment defined outside the operation and is
+-- @
+-- {
+--   user {
+--     ... on UserType {
+--       id
+--       name
+--     }
+-- }
+-- @
+data InlineFragment = InlineFragment
+    (Maybe TypeCondition) [Directive] SelectionSet Location
+    deriving (Eq, Show)
+
+-- | A fragment spread refers to a fragment defined outside the operation and is
 -- expanded at the execution time.
 --
 -- @
@@ -148,23 +198,7 @@ type SelectionSetOpt = [Selection]
 --   name
 -- }
 -- @
---
--- Inline fragments are similar but they don't have any name and the type
--- condition ("on UserType") is optional.
---
--- @
--- {
---   user {
---     ... on UserType {
---       id
---       name
---     }
--- }
--- @
-data Selection
-    = Field (Maybe Alias) Name [Argument] [Directive] SelectionSetOpt
-    | FragmentSpread Name [Directive]
-    | InlineFragment (Maybe TypeCondition) [Directive] SelectionSet
+data FragmentSpread = FragmentSpread Name [Directive] Location
     deriving (Eq, Show)
 
 -- ** Arguments
@@ -180,23 +214,7 @@ data Selection
 -- @
 --
 --  Here "id" is an argument for the field "user" and its value is 4.
-data Argument = Argument Name Value deriving (Eq,Show)
-
--- ** Field Alias
-
--- | Alternative field name.
---
--- @
--- {
---   smallPic: profilePic(size: 64)
---   bigPic: profilePic(size: 1024)
--- }
--- @
---
--- Here "smallPic" and "bigPic" are aliases for the same field, "profilePic",
--- used to distinquish between profile pictures with different arguments
--- (sizes).
-type Alias = Name
+data Argument = Argument Name (Node Value) Location deriving (Eq, Show)
 
 -- ** Fragments
 
@@ -210,6 +228,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
@@ -219,9 +265,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
@@ -231,15 +289,35 @@ 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.
 --
 -- A list of 'ObjectField's represents a GraphQL object type.
-data ObjectField a = ObjectField Name a
-    deriving (Eq, Show)
+data ObjectField a = ObjectField
+    { name :: Name
+    , value :: Node a
+    , location :: Location
+    } 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
 
@@ -248,20 +326,27 @@ data ObjectField a = ObjectField Name a
 -- 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
 -- itself. They make queries reusable.
-data VariableDefinition = VariableDefinition Name Type (Maybe ConstValue)
+data VariableDefinition =
+    VariableDefinition Name Type (Maybe (Node ConstValue)) Location
     deriving (Eq, Show)
 
+showVariableName :: VariableDefinition -> String
+showVariableName (VariableDefinition name _ _ _) = "$" <> Text.unpack name
+
+showVariable :: VariableDefinition -> String
+showVariable var@(VariableDefinition _ type' _ _) = showVariableName var <> ":" <> " " <> show type'
+
 -- ** Type References
 
 -- | Type representation.
@@ -269,7 +354,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
@@ -278,7 +368,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
 
@@ -286,7 +380,7 @@ data NonNullType
 --
 -- Directives begin with "@", can accept arguments, and can be applied to the
 -- most GraphQL elements, providing additional information.
-data Directive = Directive Name [Argument] deriving (Eq, Show)
+data Directive = Directive Name [Argument] Location deriving (Eq, Show)
 
 -- * Type System
 
@@ -370,6 +464,14 @@ data SchemaExtension
 newtype Description = Description (Maybe Text)
     deriving (Eq, Show)
 
+instance Semigroup Description
+  where
+    Description lhs <> Description rhs = Description $ lhs <> rhs
+
+instance Monoid Description
+  where
+    mempty = Description mempty
+
 -- ** Types
 
 -- | Type definitions describe various user-defined types.
@@ -485,8 +587,8 @@ instance Monoid ArgumentsDefinition where
 -- @
 --
 -- The input type "Point2D" contains two value definitions: "x" and "y".
-data InputValueDefinition
-    = InputValueDefinition Description Name Type (Maybe ConstValue) [Directive]
+data InputValueDefinition = InputValueDefinition
+    Description Name Type (Maybe (Node ConstValue)) [Directive]
     deriving (Eq, Show)
 
 -- ** Unions

src/Language/GraphQL/AST/Encoder.hs

@@ -1,6 +1,8 @@
 {-# LANGUAGE ExplicitForAll #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE Safe #-}
 
 -- | This module defines a minifier and a printer for the @GraphQL@ language.
 module Language.GraphQL.AST.Encoder
@@ -9,13 +11,14 @@ module Language.GraphQL.AST.Encoder
     , directive
     , document
     , minified
+    , operationType
     , pretty
     , type'
+    , typeSystemDefinition
     , value
     ) where
 
-import Data.Char (ord)
-import Data.Foldable (fold)
+import Data.Foldable (fold, Foldable (..))
 import qualified Data.List.NonEmpty as NonEmpty
 import Data.Text (Text)
 import qualified Data.Text as Text
@@ -23,9 +26,10 @@ 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 Language.GraphQL.AST.Document
+import qualified Language.GraphQL.AST.Document as Full
+import qualified Language.GraphQL.AST.DirectiveLocation as DirectiveLocation
 
 -- | Instructs the encoder whether the GraphQL document should be minified or
 --   pretty printed.
@@ -33,7 +37,7 @@ import Language.GraphQL.AST.Document
 --   Use 'pretty' or 'minified' to construct the formatter.
 data Formatter
     = Minified
-    | Pretty Word
+    | Pretty !Word
 
 -- | Constructs a formatter for pretty printing.
 pretty :: Formatter
@@ -44,77 +48,317 @@ minified :: Formatter
 minified = Minified
 
 -- | Converts a Document' into a string.
-document :: Formatter -> Document -> Lazy.Text
+document :: Formatter -> Full.Document -> Lazy.Text
 document formatter defs
     | Pretty _ <- formatter = Lazy.Text.intercalate "\n" encodeDocument
     | Minified <-formatter = Lazy.Text.snoc (mconcat encodeDocument) '\n'
   where
     encodeDocument = foldr executableDefinition [] defs
-    executableDefinition (ExecutableDefinition executableDefinition') acc =
+    executableDefinition (Full.ExecutableDefinition executableDefinition') acc =
         definition formatter executableDefinition' : acc
-    executableDefinition _ acc = acc
+    executableDefinition (Full.TypeSystemDefinition typeSystemDefinition' _location) acc =
+        typeSystemDefinition formatter typeSystemDefinition' : acc
+    executableDefinition (Full.TypeSystemExtension typeSystemExtension' _location) acc =
+        typeSystemExtension formatter typeSystemExtension' : acc
 
--- | Converts a t'ExecutableDefinition' into a string.
-definition :: Formatter -> ExecutableDefinition -> Lazy.Text
+directiveLocation :: DirectiveLocation.DirectiveLocation -> Lazy.Text
+directiveLocation = Lazy.Text.pack . show
+
+withLineBreak :: Formatter -> Lazy.Text.Text -> Lazy.Text.Text
+withLineBreak formatter encodeDefinition
+    | Pretty _ <- formatter = Lazy.Text.snoc encodeDefinition '\n'
+    | Minified <- formatter = encodeDefinition
+
+typeSystemExtension :: Formatter -> Full.TypeSystemExtension -> Lazy.Text
+typeSystemExtension formatter = \case
+    Full.SchemaExtension schemaExtension' ->
+        schemaExtension formatter schemaExtension'
+    Full.TypeExtension typeExtension' -> typeExtension formatter typeExtension'
+
+schemaExtension :: Formatter -> Full.SchemaExtension -> Lazy.Text
+schemaExtension formatter = \case
+    Full.SchemaOperationExtension operationDirectives operationTypeDefinitions' ->
+        withLineBreak formatter
+            $ "extend schema "
+            <> optempty (directives formatter) operationDirectives
+            <> bracesList formatter (operationTypeDefinition formatter) (NonEmpty.toList operationTypeDefinitions')
+    Full.SchemaDirectivesExtension operationDirectives -> "extend schema "
+        <> optempty (directives formatter) (NonEmpty.toList operationDirectives)
+
+typeExtension :: Formatter -> Full.TypeExtension -> Lazy.Text
+typeExtension formatter = \case
+    Full.ScalarTypeExtension name' directives'
+        -> "extend scalar "
+        <> Lazy.Text.fromStrict name'
+        <> directives formatter (NonEmpty.toList directives')
+    Full.ObjectTypeFieldsDefinitionExtension name' ifaces' directives' fields'
+        -> "extend type "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (" " <>) (implementsInterfaces ifaces')
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> bracesList formatter (fieldDefinition nextFormatter) (NonEmpty.toList fields')
+    Full.ObjectTypeDirectivesExtension name' ifaces' directives'
+        -> "extend type "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (" " <>) (implementsInterfaces ifaces')
+        <> optempty (directives formatter) (NonEmpty.toList directives')
+    Full.ObjectTypeImplementsInterfacesExtension name' ifaces'
+        -> "extend type "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (" " <>) (implementsInterfaces ifaces')
+    Full.InterfaceTypeFieldsDefinitionExtension name' directives' fields'
+        -> "extend interface "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> bracesList formatter (fieldDefinition nextFormatter) (NonEmpty.toList fields')
+    Full.InterfaceTypeDirectivesExtension name' directives'
+        -> "extend interface "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) (NonEmpty.toList directives')
+    Full.UnionTypeUnionMemberTypesExtension name' directives' members'
+        -> "extend union "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> unionMemberTypes formatter members'
+    Full.UnionTypeDirectivesExtension name' directives'
+        -> "extend union "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) (NonEmpty.toList directives')
+    Full.EnumTypeEnumValuesDefinitionExtension name' directives' members'
+        -> "extend enum "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> bracesList formatter (enumValueDefinition formatter) (NonEmpty.toList members')
+    Full.EnumTypeDirectivesExtension name' directives'
+        -> "extend enum "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) (NonEmpty.toList directives')
+    Full.InputObjectTypeInputFieldsDefinitionExtension name' directives' fields'
+        -> "extend input "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> bracesList formatter (inputValueDefinition nextFormatter) (NonEmpty.toList fields')
+    Full.InputObjectTypeDirectivesExtension name' directives'
+        -> "extend input "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) (NonEmpty.toList directives')
+  where
+    nextFormatter = incrementIndent formatter
+
+-- | Converts a t'Full.TypeSystemDefinition' into a string.
+typeSystemDefinition :: Formatter -> Full.TypeSystemDefinition -> Lazy.Text
+typeSystemDefinition formatter = \case
+    Full.SchemaDefinition operationDirectives operationTypeDefinitions' ->
+        withLineBreak formatter
+            $ "schema "
+            <> optempty (directives formatter) operationDirectives
+            <> bracesList formatter (operationTypeDefinition formatter) (NonEmpty.toList operationTypeDefinitions')
+    Full.TypeDefinition typeDefinition' -> typeDefinition formatter typeDefinition'
+    Full.DirectiveDefinition description' name' arguments' locations
+        -> description formatter description'
+        <> "@"
+        <> Lazy.Text.fromStrict name'
+        <> argumentsDefinition formatter arguments'
+        <> " on"
+        <> pipeList formatter (directiveLocation <$> locations)
+
+operationTypeDefinition :: Formatter -> Full.OperationTypeDefinition -> Lazy.Text.Text
+operationTypeDefinition formatter (Full.OperationTypeDefinition operationType' namedType')
+    = indentLine (incrementIndent formatter)
+    <> operationType formatter operationType'
+    <> colon formatter
+    <> Lazy.Text.fromStrict namedType'
+
+fieldDefinition :: Formatter -> Full.FieldDefinition -> Lazy.Text.Text
+fieldDefinition formatter fieldDefinition' =
+    let Full.FieldDefinition description' name' arguments' type'' directives' = fieldDefinition'
+     in optempty (description formatter) description'
+            <> indentLine formatter
+            <> Lazy.Text.fromStrict name'
+            <> argumentsDefinition formatter arguments'
+            <> colon formatter
+            <> type' type''
+            <> optempty (directives formatter) directives'
+
+argumentsDefinition :: Formatter -> Full.ArgumentsDefinition -> Lazy.Text.Text
+argumentsDefinition formatter (Full.ArgumentsDefinition arguments') =
+    parensCommas formatter (argumentDefinition formatter) arguments'
+
+argumentDefinition :: Formatter -> Full.InputValueDefinition -> Lazy.Text.Text
+argumentDefinition formatter definition' =
+    let Full.InputValueDefinition description' name' type'' defaultValue' directives' = definition'
+     in optempty (description formatter) description'
+            <> Lazy.Text.fromStrict name'
+            <> colon formatter
+            <> type' type''
+            <> maybe mempty (defaultValue formatter . Full.node) defaultValue'
+            <> directives formatter directives'
+
+inputValueDefinition :: Formatter -> Full.InputValueDefinition -> Lazy.Text.Text
+inputValueDefinition formatter definition' =
+    let Full.InputValueDefinition description' name' type'' defaultValue' directives' = definition'
+     in optempty (description formatter) description'
+            <> indentLine formatter
+            <> Lazy.Text.fromStrict name'
+            <> colon formatter
+            <> type' type''
+            <> maybe mempty (defaultValue formatter . Full.node) defaultValue'
+            <> directives formatter directives'
+
+typeDefinition :: Formatter -> Full.TypeDefinition -> Lazy.Text
+typeDefinition formatter = \case
+    Full.ScalarTypeDefinition description' name' directives'
+        -> optempty (description formatter) description'
+        <> "scalar "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) directives'
+    Full.ObjectTypeDefinition description' name' ifaces' directives' fields'
+        -> optempty (description formatter) description'
+        <> "type "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (" " <>) (implementsInterfaces ifaces')
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> bracesList formatter (fieldDefinition nextFormatter) fields'
+    Full.InterfaceTypeDefinition description' name' directives' fields'
+        -> optempty (description formatter) description'
+        <> "interface "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> bracesList formatter (fieldDefinition nextFormatter) fields'
+    Full.UnionTypeDefinition description' name' directives' members'
+        -> optempty (description formatter) description'
+        <> "union "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> unionMemberTypes formatter members'
+    Full.EnumTypeDefinition description' name' directives' members'
+        -> optempty (description formatter) description'
+        <> "enum "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> bracesList formatter (enumValueDefinition formatter) members'
+    Full.InputObjectTypeDefinition description' name' directives' fields'
+        -> optempty (description formatter) description'
+        <> "input "
+        <> Lazy.Text.fromStrict name'
+        <> optempty (directives formatter) directives'
+        <> eitherFormat formatter " " ""
+        <> bracesList formatter (inputValueDefinition nextFormatter) fields'
+  where
+    nextFormatter = incrementIndent formatter
+
+implementsInterfaces :: Foldable t => Full.ImplementsInterfaces t -> Lazy.Text
+implementsInterfaces (Full.ImplementsInterfaces interfaces)
+    | null interfaces = mempty
+    | otherwise = Lazy.Text.fromStrict
+        $ Text.append "implements "
+        $ Text.intercalate " & "
+        $ toList interfaces
+
+unionMemberTypes :: Foldable t => Formatter -> Full.UnionMemberTypes t -> Lazy.Text
+unionMemberTypes formatter (Full.UnionMemberTypes memberTypes)
+    | null memberTypes = mempty
+    | otherwise = Lazy.Text.append "="
+        $ pipeList formatter
+        $ Lazy.Text.fromStrict
+        <$> toList memberTypes
+
+pipeList :: Foldable t => Formatter -> t Lazy.Text -> Lazy.Text
+pipeList Minified =  (" " <>) . Lazy.Text.intercalate " | " . toList
+pipeList (Pretty _) =  Lazy.Text.concat
+    . fmap (("\n" <> indentSymbol <> "| ") <>)
+    . toList 
+
+enumValueDefinition :: Formatter -> Full.EnumValueDefinition -> Lazy.Text
+enumValueDefinition (Pretty _) enumValue =
+    let Full.EnumValueDefinition description' name' directives' = enumValue
+        formatter = Pretty 1
+     in description formatter description'
+        <> indentLine formatter
+        <> Lazy.Text.fromStrict name'
+        <> directives formatter directives'
+enumValueDefinition Minified enumValue =
+    let Full.EnumValueDefinition description' name' directives' = enumValue
+     in description Minified description'
+        <> Lazy.Text.fromStrict name'
+        <> directives Minified directives'
+
+description :: Formatter -> Full.Description -> Lazy.Text.Text
+description _formatter (Full.Description Nothing) = ""
+description formatter (Full.Description (Just description')) =
+    stringValue formatter description'
+
+-- | Converts a t'Full.ExecutableDefinition' into a string.
+definition :: Formatter -> Full.ExecutableDefinition -> Lazy.Text
 definition formatter x
     | Pretty _ <- formatter = Lazy.Text.snoc (encodeDefinition x) '\n'
     | Minified <- formatter = encodeDefinition x
   where
-    encodeDefinition (DefinitionOperation operation)
+    encodeDefinition (Full.DefinitionOperation operation)
         = operationDefinition formatter operation
-    encodeDefinition (DefinitionFragment fragment)
+    encodeDefinition (Full.DefinitionFragment fragment)
         = fragmentDefinition formatter fragment
 
--- | Converts a 'OperationDefinition into a string.
-operationDefinition :: Formatter -> OperationDefinition -> Lazy.Text
+-- | Converts a 'Full.OperationDefinition into a string.
+operationDefinition :: Formatter -> Full.OperationDefinition -> Lazy.Text
 operationDefinition formatter = \case
-    SelectionSet sels _ -> selectionSet formatter sels
-    OperationDefinition Query name vars dirs sels _ ->
-        "query " <> node formatter name vars dirs sels
-    OperationDefinition Mutation name vars dirs sels _ ->
-        "mutation " <> node formatter name vars dirs sels
-    OperationDefinition Subscription name vars dirs sels _ ->
-        "subscription " <> node formatter name vars dirs sels
+    Full.SelectionSet sels _ -> selectionSet formatter sels
+    Full.OperationDefinition Full.Query name vars dirs sels _ ->
+        "query " <> root name vars dirs sels
+    Full.OperationDefinition Full.Mutation name vars dirs sels _ ->
+        "mutation " <> root name vars dirs sels
+    Full.OperationDefinition Full.Subscription name vars dirs sels _ ->
+        "subscription " <> root name vars dirs sels
+  where
+    -- | Converts a Query or Mutation into a string.
+    root :: Maybe Full.Name ->
+        [Full.VariableDefinition] ->
+        [Full.Directive] ->
+        Full.SelectionSet ->
+        Lazy.Text
+    root name vars dirs sels
+        = Lazy.Text.fromStrict (fold name)
+        <> optempty (variableDefinitions formatter) vars
+        <> optempty (directives formatter) dirs
+        <> eitherFormat formatter " " mempty
+        <> selectionSet formatter sels
 
--- | Converts a Query or Mutation into a string.
-node :: Formatter ->
-    Maybe Name ->
-    [VariableDefinition] ->
-    [Directive] ->
-    SelectionSet ->
-    Lazy.Text
-node formatter name vars dirs sels
-    = Lazy.Text.fromStrict (fold name)
-    <> optempty (variableDefinitions formatter) vars
-    <> optempty (directives formatter) dirs
-    <> eitherFormat formatter " " mempty
-    <> selectionSet formatter sels
-
-variableDefinitions :: Formatter -> [VariableDefinition] -> Lazy.Text
+variableDefinitions :: Formatter -> [Full.VariableDefinition] -> Lazy.Text
 variableDefinitions formatter
     = parensCommas formatter $ variableDefinition formatter
 
-variableDefinition :: Formatter -> VariableDefinition -> Lazy.Text
-variableDefinition formatter (VariableDefinition var ty defaultValue')
-    = variable var
-    <> eitherFormat formatter ": " ":"
-    <> type' ty
-    <> maybe mempty (defaultValue formatter) defaultValue'
+variableDefinition :: Formatter -> Full.VariableDefinition -> Lazy.Text
+variableDefinition formatter variableDefinition' =
+    let Full.VariableDefinition variableName variableType defaultValue' _ =
+            variableDefinition'
+     in variable variableName
+    <> colon formatter
+    <> type' variableType
+    <> maybe mempty (defaultValue formatter . Full.node) defaultValue'
 
-defaultValue :: Formatter -> ConstValue -> Lazy.Text
+defaultValue :: Formatter -> Full.ConstValue -> Lazy.Text
 defaultValue formatter val
     = eitherFormat formatter " = " "="
     <> value formatter (fromConstValue val)
 
-variable :: Name -> Lazy.Text
+variable :: Full.Name -> Lazy.Text
 variable var = "$" <> Lazy.Text.fromStrict var
 
-selectionSet :: Formatter -> SelectionSet -> Lazy.Text
+selectionSet :: Formatter -> Full.SelectionSet -> Lazy.Text
 selectionSet formatter
     = bracesList formatter (selection formatter)
     . NonEmpty.toList
 
-selectionSetOpt :: Formatter -> SelectionSetOpt -> Lazy.Text
+selectionSetOpt :: Formatter -> Full.SelectionSetOpt -> Lazy.Text
 selectionSetOpt formatter = bracesList formatter $ selection formatter
 
 indentSymbol :: Lazy.Text
@@ -123,34 +367,34 @@ indentSymbol = "  "
 indent :: (Integral a) => a -> Lazy.Text
 indent indentation = Lazy.Text.replicate (fromIntegral indentation) indentSymbol
 
-selection :: Formatter -> Selection -> Lazy.Text
-selection formatter = Lazy.Text.append indent' . encodeSelection
+selection :: Formatter -> Full.Selection -> Lazy.Text
+selection formatter = Lazy.Text.append (indentLine formatter')
+    . encodeSelection
   where
-    encodeSelection (Field alias name args directives' selections) =
-        field incrementIndent alias name args directives' selections
-    encodeSelection (InlineFragment typeCondition directives' selections) =
-        inlineFragment incrementIndent typeCondition directives' selections
-    encodeSelection (FragmentSpread name directives') =
-        fragmentSpread incrementIndent name directives'
-    incrementIndent
-        | Pretty indentation <- formatter = Pretty $ indentation + 1
-        | otherwise = Minified
-    indent'
-        | Pretty indentation <- formatter = indent $ indentation + 1
-        | otherwise = ""
+    encodeSelection (Full.FieldSelection fieldSelection) =
+        field formatter' fieldSelection
+    encodeSelection (Full.InlineFragmentSelection fragmentSelection) =
+        inlineFragment formatter' fragmentSelection
+    encodeSelection (Full.FragmentSpreadSelection fragmentSelection) =
+        fragmentSpread formatter' fragmentSelection
+    formatter' = incrementIndent formatter
+
+indentLine :: Formatter -> Lazy.Text
+indentLine formatter
+    | Pretty indentation <- formatter = indent indentation
+    | otherwise = ""
+
+incrementIndent :: Formatter -> Formatter
+incrementIndent formatter
+    | Pretty indentation <- formatter = Pretty $ indentation + 1
+    | otherwise = Minified
 
 colon :: Formatter -> Lazy.Text
 colon formatter = eitherFormat formatter ": " ":"
 
--- | Converts Field into a string
-field :: Formatter ->
-    Maybe Name ->
-    Name ->
-    [Argument] ->
-    [Directive] ->
-    [Selection] ->
-    Lazy.Text
-field formatter alias name args dirs set
+-- | Converts Field into a string.
+field :: Formatter -> Full.Field -> Lazy.Text
+field formatter (Full.Field alias name args dirs set _)
     = optempty prependAlias (fold alias)
     <> Lazy.Text.fromStrict name
     <> optempty (arguments formatter) args
@@ -161,36 +405,32 @@ field formatter alias name args dirs set
     selectionSetOpt' = (eitherFormat formatter " " "" <>)
         . selectionSetOpt formatter
 
-arguments :: Formatter -> [Argument] -> Lazy.Text
+arguments :: Formatter -> [Full.Argument] -> Lazy.Text
 arguments formatter = parensCommas formatter $ argument formatter
 
-argument :: Formatter -> Argument -> Lazy.Text
-argument formatter (Argument name value')
+argument :: Formatter -> Full.Argument -> Lazy.Text
+argument formatter (Full.Argument name value' _)
     = Lazy.Text.fromStrict name
     <> colon formatter
-    <> value formatter value'
+    <> value formatter (Full.node value')
 
 -- * Fragments
 
-fragmentSpread :: Formatter -> Name -> [Directive] -> Lazy.Text
-fragmentSpread formatter name directives'
+fragmentSpread :: Formatter -> Full.FragmentSpread -> Lazy.Text
+fragmentSpread formatter (Full.FragmentSpread name directives' _)
     = "..." <> Lazy.Text.fromStrict name
     <> optempty (directives formatter) directives'
 
-inlineFragment ::
-    Formatter ->
-    Maybe TypeCondition ->
-    [Directive] ->
-    SelectionSet ->
-    Lazy.Text
-inlineFragment formatter tc dirs sels = "... on "
-    <> Lazy.Text.fromStrict (fold tc)
-    <> directives formatter dirs
+inlineFragment :: Formatter -> Full.InlineFragment -> Lazy.Text
+inlineFragment formatter (Full.InlineFragment typeCondition directives' selections _)
+    = "... on "
+    <> Lazy.Text.fromStrict (fold typeCondition)
+    <> directives formatter directives'
     <> eitherFormat formatter " " mempty
-    <> selectionSet formatter sels
+    <> selectionSet formatter selections
 
-fragmentDefinition :: Formatter -> FragmentDefinition -> Lazy.Text
-fragmentDefinition formatter (FragmentDefinition name tc dirs sels _)
+fragmentDefinition :: Formatter -> Full.FragmentDefinition -> Lazy.Text
+fragmentDefinition formatter (Full.FragmentDefinition name tc dirs sels _)
     = "fragment " <> Lazy.Text.fromStrict name
     <> " on " <> Lazy.Text.fromStrict tc
     <> optempty (directives formatter) dirs
@@ -199,39 +439,41 @@ fragmentDefinition formatter (FragmentDefinition name tc dirs sels _)
 
 -- * Miscellaneous
 
--- | Converts a 'Directive' into a string.
-directive :: Formatter -> Directive -> Lazy.Text
-directive formatter (Directive name args)
+-- | Converts a 'Full.Directive' into a string.
+directive :: Formatter -> Full.Directive -> Lazy.Text
+directive formatter (Full.Directive name args _)
     = "@" <> Lazy.Text.fromStrict name <> optempty (arguments formatter) args
 
-directives :: Formatter -> [Directive] -> Lazy.Text
-directives Minified = spaces (directive Minified)
-directives formatter = Lazy.Text.cons ' ' . spaces (directive formatter)
+directives :: Formatter -> [Full.Directive] -> Lazy.Text
+directives Minified values = spaces (directive Minified) values
+directives formatter values
+    | null values = ""
+    | otherwise = Lazy.Text.cons ' ' $ spaces (directive formatter) values
 
--- | Converts a 'Value' into a string.
-value :: Formatter -> Value -> Lazy.Text
-value _ (Variable x) = variable x
-value _ (Int x) = Builder.toLazyText $ decimal x
-value _ (Float x) = Builder.toLazyText $ realFloat x
-value _ (Boolean  x) = booleanValue x
-value _ Null = "null"
-value formatter (String string) = stringValue formatter string
-value _ (Enum x) = Lazy.Text.fromStrict x
-value formatter (List x) = listValue formatter x
-value formatter (Object x) = objectValue formatter x
+-- | Converts a 'Full.Value' into a string.
+value :: Formatter -> Full.Value -> Lazy.Text
+value _ (Full.Variable x) = variable x
+value _ (Full.Int x) = Builder.toLazyText $ decimal x
+value _ (Full.Float x) = Builder.toLazyText $ realFloat x
+value _ (Full.Boolean  x) = booleanValue x
+value _ Full.Null = "null"
+value formatter (Full.String string) = stringValue formatter string
+value _ (Full.Enum x) = Lazy.Text.fromStrict x
+value formatter (Full.List x) = listValue formatter x
+value formatter (Full.Object x) = objectValue formatter x
 
-fromConstValue :: ConstValue -> Value
-fromConstValue (ConstInt x) = Int x
-fromConstValue (ConstFloat x) = Float x
-fromConstValue (ConstBoolean  x) = Boolean x
-fromConstValue ConstNull = Null
-fromConstValue (ConstString string) = String string
-fromConstValue (ConstEnum x) = Enum x
-fromConstValue (ConstList x) = List $ fromConstValue <$> x
-fromConstValue (ConstObject x) = Object $ fromConstObjectField <$> x
+fromConstValue :: Full.ConstValue -> Full.Value
+fromConstValue (Full.ConstInt x) = Full.Int x
+fromConstValue (Full.ConstFloat x) = Full.Float x
+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 $ fmap fromConstValue <$> x
+fromConstValue (Full.ConstObject x) = Full.Object $ fromConstObjectField <$> x
   where
-    fromConstObjectField (ObjectField key value') =
-        ObjectField key $ fromConstValue value'
+    fromConstObjectField Full.ObjectField{value = value', ..} =
+        Full.ObjectField name (fromConstValue <$> value') location
 
 booleanValue :: Bool -> Lazy.Text
 booleanValue True  = "true"
@@ -241,11 +483,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
-    $ quote <> Text.foldr (mappend . escape) quote string
+stringValue Minified string = Builder.toLazyText $ oneLine string
 stringValue (Pretty indentation) string =
   if hasEscaped string
   then stringValue Minified string
@@ -273,25 +516,10 @@ stringValue (Pretty indentation) string =
             = Builder.fromLazyText (indent (indentation + 1))
             <> line' <> newline <> acc
 
-escape :: Char -> Builder
-escape char'
-    | 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.Node Full.Value] -> Lazy.Text
+listValue formatter = bracketsCommas formatter $ value formatter . Full.node
 
-listValue :: Formatter -> [Value] -> Lazy.Text
-listValue formatter = bracketsCommas formatter $ value formatter
-
-objectValue :: Formatter -> [ObjectField Value] -> Lazy.Text
+objectValue :: Formatter -> [Full.ObjectField Full.Value] -> Lazy.Text
 objectValue formatter = intercalate $ objectField formatter
   where
     intercalate f
@@ -299,22 +527,28 @@ objectValue formatter = intercalate $ objectField formatter
         . Lazy.Text.intercalate (eitherFormat formatter ", " ",")
         . fmap f
 
-objectField :: Formatter -> ObjectField Value -> Lazy.Text
-objectField formatter (ObjectField name value') =
+objectField :: Formatter -> Full.ObjectField Full.Value -> Lazy.Text
+objectField formatter (Full.ObjectField name (Full.Node value' _) _) =
     Lazy.Text.fromStrict name <> colon formatter <> value formatter value'
 
--- | Converts a 'Type' a type into a string.
-type' :: Type -> Lazy.Text
-type' (TypeNamed   x) = Lazy.Text.fromStrict x
-type' (TypeList    x) = listType x
-type' (TypeNonNull x) = nonNullType x
+-- | Converts a 'Full.Type' a type into a string.
+type' :: Full.Type -> Lazy.Text
+type' (Full.TypeNamed x) = Lazy.Text.fromStrict x
+type' (Full.TypeList x) = listType x
+type' (Full.TypeNonNull x) = nonNullType x
 
-listType :: Type -> Lazy.Text
+listType :: Full.Type -> Lazy.Text
 listType x = brackets (type' x)
 
-nonNullType :: NonNullType -> Lazy.Text
-nonNullType (NonNullTypeNamed x) = Lazy.Text.fromStrict x <> "!"
-nonNullType (NonNullTypeList  x) = listType x <> "!"
+nonNullType :: Full.NonNullType -> Lazy.Text
+nonNullType (Full.NonNullTypeNamed x) = Lazy.Text.fromStrict x <> "!"
+nonNullType (Full.NonNullTypeList x) = listType x <> "!"
+
+-- | Produces lowercase operation type: query, mutation or subscription.
+operationType :: Formatter -> Full.OperationType -> Lazy.Text
+operationType _formatter Full.Query = "query"
+operationType _formatter Full.Mutation = "mutation"
+operationType _formatter Full.Subscription = "subscription"
 
 -- * Internal
 

src/Language/GraphQL/AST/Lexer.hs

@@ -58,6 +58,7 @@ import qualified Text.Megaparsec.Char.Lexer as Lexer
 import Data.Text (Text)
 import qualified Data.Text as T
 import qualified Data.Text.Lazy as TL
+import Control.Monad (void)
 
 -- | Standard parser.
 -- Accepts the type of the parsed token.
@@ -92,16 +93,16 @@ dollar :: Parser T.Text
 dollar = symbol "$"
 
 -- | Parser for "@".
-at :: Parser Text
-at = symbol "@"
+at :: Parser ()
+at = void $ symbol "@"
 
 -- | Parser for "&".
 amp :: Parser T.Text
 amp = symbol "&"
 
 -- | Parser for ":".
-colon :: Parser T.Text
-colon = symbol ":"
+colon :: Parser ()
+colon = void $ symbol ":"
 
 -- | Parser for "=".
 equals :: Parser T.Text
@@ -220,7 +221,7 @@ escapeSequence = do
 
 -- | Parser for the "Byte Order Mark".
 unicodeBOM :: Parser ()
-unicodeBOM = optional (char '\xfeff') >> pure ()
+unicodeBOM = void $ optional $ char '\xfeff'
 
 -- | Parses "extend" followed by a 'symbol'. It is used by schema extensions.
 extend :: forall a. Text -> String -> NonEmpty (Parser a) -> Parser a

src/Language/GraphQL/AST/Parser.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE ExplicitForAll #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
@@ -13,12 +14,8 @@ 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
-    ( DirectiveLocation
-    , ExecutableDirectiveLocation
-    , TypeSystemDirectiveLocation
-    )
-import Language.GraphQL.AST.Document
+import Language.GraphQL.AST.DirectiveLocation (DirectiveLocation)
+import qualified Language.GraphQL.AST.Document as Full
 import Language.GraphQL.AST.Lexer
 import Text.Megaparsec
     ( MonadParsec(..)
@@ -32,13 +29,13 @@ import Text.Megaparsec
     )
 
 -- | Parser for the GraphQL documents.
-document :: Parser Document
+document :: Parser Full.Document
 document = unicodeBOM
     *> spaceConsumer
     *> lexeme (NonEmpty.some definition)
 
-definition :: Parser Definition
-definition = ExecutableDefinition <$> executableDefinition
+definition :: Parser Full.Definition
+definition = Full.ExecutableDefinition <$> executableDefinition
     <|> typeSystemDefinition'
     <|> typeSystemExtension'
     <?> "Definition"
@@ -46,41 +43,41 @@ definition = ExecutableDefinition <$> executableDefinition
     typeSystemDefinition' = do
         location <- getLocation
         definition' <- typeSystemDefinition
-        pure $ TypeSystemDefinition definition' location
+        pure $ Full.TypeSystemDefinition definition' location
     typeSystemExtension' = do
         location <- getLocation
         definition' <- typeSystemExtension
-        pure $ TypeSystemExtension definition' location
+        pure $ Full.TypeSystemExtension definition' location
 
-getLocation :: Parser Location
+getLocation :: Parser Full.Location
 getLocation = fromSourcePosition <$> getSourcePos
   where
     fromSourcePosition SourcePos{..} =
-        Location (wordFromPosition sourceLine) (wordFromPosition sourceColumn)
+        Full.Location (wordFromPosition sourceLine) (wordFromPosition sourceColumn)
     wordFromPosition = fromIntegral . unPos
 
-executableDefinition :: Parser ExecutableDefinition
-executableDefinition = DefinitionOperation <$> operationDefinition
-    <|> DefinitionFragment  <$> fragmentDefinition
+executableDefinition :: Parser Full.ExecutableDefinition
+executableDefinition = Full.DefinitionOperation <$> operationDefinition
+    <|> Full.DefinitionFragment  <$> fragmentDefinition
     <?> "ExecutableDefinition"
 
-typeSystemDefinition :: Parser TypeSystemDefinition
+typeSystemDefinition :: Parser Full.TypeSystemDefinition
 typeSystemDefinition = schemaDefinition
     <|> typeSystemDefinitionWithDescription
     <?> "TypeSystemDefinition"
   where
     typeSystemDefinitionWithDescription = description
         >>= liftA2 (<|>) typeDefinition' directiveDefinition
-    typeDefinition' description' = TypeDefinition
+    typeDefinition' description' = Full.TypeDefinition
         <$> typeDefinition description'
 
-typeSystemExtension :: Parser TypeSystemExtension
-typeSystemExtension = SchemaExtension <$> schemaExtension
-    <|> TypeExtension <$> typeExtension
+typeSystemExtension :: Parser Full.TypeSystemExtension
+typeSystemExtension = Full.SchemaExtension <$> schemaExtension
+    <|> Full.TypeExtension <$> typeExtension
     <?> "TypeSystemExtension"
 
-directiveDefinition :: Description -> Parser TypeSystemDefinition
-directiveDefinition description' = DirectiveDefinition description'
+directiveDefinition :: Full.Description -> Parser Full.TypeSystemDefinition
+directiveDefinition description' = Full.DirectiveDefinition description'
     <$ symbol "directive"
     <* at
     <*> name
@@ -95,36 +92,30 @@ directiveLocations = optional pipe
     <?> "DirectiveLocations"
 
 directiveLocation :: Parser DirectiveLocation
-directiveLocation
-    = Directive.ExecutableDirectiveLocation <$> executableDirectiveLocation
-    <|> Directive.TypeSystemDirectiveLocation <$> typeSystemDirectiveLocation
+directiveLocation = e (Directive.Query <$ symbol "QUERY")
+    <|> e (Directive.Mutation <$ symbol "MUTATION")
+    <|> 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
+    e = fmap Directive.ExecutableDirectiveLocation
+    t = fmap Directive.TypeSystemDirectiveLocation
 
-executableDirectiveLocation :: Parser ExecutableDirectiveLocation
-executableDirectiveLocation = Directive.Query <$ symbol "QUERY"
-    <|> 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 :: Description -> Parser TypeDefinition
+typeDefinition :: Full.Description -> Parser Full.TypeDefinition
 typeDefinition description' = scalarTypeDefinition description'
     <|> objectTypeDefinition description'
     <|> interfaceTypeDefinition description'
@@ -133,7 +124,7 @@ typeDefinition description' = scalarTypeDefinition description'
     <|> inputObjectTypeDefinition description'
     <?> "TypeDefinition"
 
-typeExtension :: Parser TypeExtension
+typeExtension :: Parser Full.TypeExtension
 typeExtension = scalarTypeExtension
     <|> objectTypeExtension
     <|> interfaceTypeExtension
@@ -142,143 +133,143 @@ typeExtension = scalarTypeExtension
     <|> inputObjectTypeExtension
     <?> "TypeExtension"
 
-scalarTypeDefinition :: Description -> Parser TypeDefinition
-scalarTypeDefinition description' = ScalarTypeDefinition description'
+scalarTypeDefinition :: Full.Description -> Parser Full.TypeDefinition
+scalarTypeDefinition description' = Full.ScalarTypeDefinition description'
     <$ symbol "scalar"
     <*> name
     <*> directives
     <?> "ScalarTypeDefinition"
 
-scalarTypeExtension :: Parser TypeExtension
+scalarTypeExtension :: Parser Full.TypeExtension
 scalarTypeExtension = extend "scalar" "ScalarTypeExtension"
-    $ (ScalarTypeExtension <$> name <*> NonEmpty.some directive) :| []
+    $ (Full.ScalarTypeExtension <$> name <*> NonEmpty.some directive) :| []
 
-objectTypeDefinition :: Description -> Parser TypeDefinition
-objectTypeDefinition description' = ObjectTypeDefinition description'
+objectTypeDefinition :: Full.Description -> Parser Full.TypeDefinition
+objectTypeDefinition description' = Full.ObjectTypeDefinition description'
     <$ symbol "type"
     <*> name
-    <*> option (ImplementsInterfaces []) (implementsInterfaces sepBy1)
+    <*> option (Full.ImplementsInterfaces []) (implementsInterfaces sepBy1)
     <*> directives
     <*> braces (many fieldDefinition)
     <?> "ObjectTypeDefinition"
 
-objectTypeExtension :: Parser TypeExtension
+objectTypeExtension :: Parser Full.TypeExtension
 objectTypeExtension = extend "type" "ObjectTypeExtension"
     $ fieldsDefinitionExtension :|
         [ directivesExtension
         , implementsInterfacesExtension
         ]
   where
-    fieldsDefinitionExtension = ObjectTypeFieldsDefinitionExtension
+    fieldsDefinitionExtension = Full.ObjectTypeFieldsDefinitionExtension
         <$> name
-        <*> option (ImplementsInterfaces []) (implementsInterfaces sepBy1)
+        <*> option (Full.ImplementsInterfaces []) (implementsInterfaces sepBy1)
         <*> directives
         <*> braces (NonEmpty.some fieldDefinition)
-    directivesExtension = ObjectTypeDirectivesExtension
+    directivesExtension = Full.ObjectTypeDirectivesExtension
         <$> name
-        <*> option (ImplementsInterfaces []) (implementsInterfaces sepBy1)
+        <*> option (Full.ImplementsInterfaces []) (implementsInterfaces sepBy1)
         <*> NonEmpty.some directive
-    implementsInterfacesExtension = ObjectTypeImplementsInterfacesExtension
+    implementsInterfacesExtension = Full.ObjectTypeImplementsInterfacesExtension
         <$> name
         <*> implementsInterfaces NonEmpty.sepBy1
 
-description :: Parser Description
-description = Description
+description :: Parser Full.Description
+description = Full.Description
     <$> optional stringValue
     <?> "Description"
 
-unionTypeDefinition :: Description -> Parser TypeDefinition
-unionTypeDefinition description' = UnionTypeDefinition description'
+unionTypeDefinition :: Full.Description -> Parser Full.TypeDefinition
+unionTypeDefinition description' = Full.UnionTypeDefinition description'
     <$ symbol "union"
     <*> name
     <*> directives
-    <*> option (UnionMemberTypes []) (unionMemberTypes sepBy1)
+    <*> option (Full.UnionMemberTypes []) (unionMemberTypes sepBy1)
     <?> "UnionTypeDefinition"
 
-unionTypeExtension :: Parser TypeExtension
+unionTypeExtension :: Parser Full.TypeExtension
 unionTypeExtension = extend "union" "UnionTypeExtension"
     $ unionMemberTypesExtension :| [directivesExtension]
   where
-    unionMemberTypesExtension = UnionTypeUnionMemberTypesExtension
+    unionMemberTypesExtension = Full.UnionTypeUnionMemberTypesExtension
         <$> name
         <*> directives
         <*> unionMemberTypes NonEmpty.sepBy1
-    directivesExtension = UnionTypeDirectivesExtension
+    directivesExtension = Full.UnionTypeDirectivesExtension
         <$> name
         <*> NonEmpty.some directive
 
 unionMemberTypes ::
     Foldable t =>
-    (Parser Text -> Parser Text -> Parser (t NamedType)) ->
-    Parser (UnionMemberTypes t)
-unionMemberTypes sepBy' = UnionMemberTypes
+    (Parser Text -> Parser Text -> Parser (t Full.NamedType)) ->
+    Parser (Full.UnionMemberTypes t)
+unionMemberTypes sepBy' = Full.UnionMemberTypes
     <$ equals
     <* optional pipe
     <*> name `sepBy'` pipe
     <?> "UnionMemberTypes"
 
-interfaceTypeDefinition :: Description -> Parser TypeDefinition
-interfaceTypeDefinition description' = InterfaceTypeDefinition description'
+interfaceTypeDefinition :: Full.Description -> Parser Full.TypeDefinition
+interfaceTypeDefinition description' = Full.InterfaceTypeDefinition description'
     <$ symbol "interface"
     <*> name
     <*> directives
     <*> braces (many fieldDefinition)
     <?> "InterfaceTypeDefinition"
 
-interfaceTypeExtension :: Parser TypeExtension
+interfaceTypeExtension :: Parser Full.TypeExtension
 interfaceTypeExtension = extend "interface" "InterfaceTypeExtension"
     $ fieldsDefinitionExtension :| [directivesExtension]
   where
-    fieldsDefinitionExtension = InterfaceTypeFieldsDefinitionExtension
+    fieldsDefinitionExtension = Full.InterfaceTypeFieldsDefinitionExtension
         <$> name
         <*> directives
         <*> braces (NonEmpty.some fieldDefinition)
-    directivesExtension = InterfaceTypeDirectivesExtension
+    directivesExtension = Full.InterfaceTypeDirectivesExtension
         <$> name
         <*> NonEmpty.some directive
 
-enumTypeDefinition :: Description -> Parser TypeDefinition
-enumTypeDefinition description' = EnumTypeDefinition description'
+enumTypeDefinition :: Full.Description -> Parser Full.TypeDefinition
+enumTypeDefinition description' = Full.EnumTypeDefinition description'
     <$ symbol "enum"
     <*> name
     <*> directives
     <*> listOptIn braces enumValueDefinition
     <?> "EnumTypeDefinition"
 
-enumTypeExtension :: Parser TypeExtension
+enumTypeExtension :: Parser Full.TypeExtension
 enumTypeExtension = extend "enum" "EnumTypeExtension"
     $ enumValuesDefinitionExtension :| [directivesExtension]
   where
-    enumValuesDefinitionExtension = EnumTypeEnumValuesDefinitionExtension
+    enumValuesDefinitionExtension = Full.EnumTypeEnumValuesDefinitionExtension
         <$> name
         <*> directives
         <*> braces (NonEmpty.some enumValueDefinition)
-    directivesExtension = EnumTypeDirectivesExtension
+    directivesExtension = Full.EnumTypeDirectivesExtension
         <$> name
         <*> NonEmpty.some directive
 
-inputObjectTypeDefinition :: Description -> Parser TypeDefinition
-inputObjectTypeDefinition description' = InputObjectTypeDefinition description'
+inputObjectTypeDefinition :: Full.Description -> Parser Full.TypeDefinition
+inputObjectTypeDefinition description' = Full.InputObjectTypeDefinition description'
     <$ symbol "input"
     <*> name
     <*> directives
     <*> listOptIn braces inputValueDefinition
     <?> "InputObjectTypeDefinition"
 
-inputObjectTypeExtension :: Parser TypeExtension
+inputObjectTypeExtension :: Parser Full.TypeExtension
 inputObjectTypeExtension = extend "input" "InputObjectTypeExtension"
     $ inputFieldsDefinitionExtension :| [directivesExtension]
   where
-    inputFieldsDefinitionExtension = InputObjectTypeInputFieldsDefinitionExtension
+    inputFieldsDefinitionExtension = Full.InputObjectTypeInputFieldsDefinitionExtension
         <$> name
         <*> directives
         <*> braces (NonEmpty.some inputValueDefinition)
-    directivesExtension = InputObjectTypeDirectivesExtension
+    directivesExtension = Full.InputObjectTypeDirectivesExtension
         <$> name
         <*> NonEmpty.some directive
 
-enumValueDefinition :: Parser EnumValueDefinition
-enumValueDefinition = EnumValueDefinition
+enumValueDefinition :: Parser Full.EnumValueDefinition
+enumValueDefinition = Full.EnumValueDefinition
     <$> description
     <*> enumValue
     <*> directives
@@ -286,16 +277,16 @@ enumValueDefinition = EnumValueDefinition
 
 implementsInterfaces ::
     Foldable t =>
-    (Parser Text -> Parser Text -> Parser (t NamedType)) ->
-    Parser (ImplementsInterfaces t)
-implementsInterfaces sepBy' = ImplementsInterfaces
+    (Parser Text -> Parser Text -> Parser (t Full.NamedType)) ->
+    Parser (Full.ImplementsInterfaces t)
+implementsInterfaces sepBy' = Full.ImplementsInterfaces
     <$ symbol "implements"
     <* optional amp
     <*> name `sepBy'` amp
     <?> "ImplementsInterfaces"
 
-inputValueDefinition :: Parser InputValueDefinition
-inputValueDefinition = InputValueDefinition
+inputValueDefinition :: Parser Full.InputValueDefinition
+inputValueDefinition = Full.InputValueDefinition
     <$> description
     <*> name
     <* colon
@@ -304,13 +295,13 @@ inputValueDefinition = InputValueDefinition
     <*> directives
     <?> "InputValueDefinition"
 
-argumentsDefinition :: Parser ArgumentsDefinition
-argumentsDefinition = ArgumentsDefinition
+argumentsDefinition :: Parser Full.ArgumentsDefinition
+argumentsDefinition = Full.ArgumentsDefinition
     <$> listOptIn parens inputValueDefinition
     <?> "ArgumentsDefinition"
 
-fieldDefinition :: Parser FieldDefinition
-fieldDefinition = FieldDefinition
+fieldDefinition :: Parser Full.FieldDefinition
+fieldDefinition = Full.FieldDefinition
     <$> description
     <*> name
     <*> argumentsDefinition
@@ -319,33 +310,33 @@ fieldDefinition = FieldDefinition
     <*> directives
     <?> "FieldDefinition"
 
-schemaDefinition :: Parser TypeSystemDefinition
-schemaDefinition = SchemaDefinition
+schemaDefinition :: Parser Full.TypeSystemDefinition
+schemaDefinition = Full.SchemaDefinition
     <$ symbol "schema"
     <*> directives
     <*> operationTypeDefinitions
     <?> "SchemaDefinition"
 
-operationTypeDefinitions :: Parser (NonEmpty OperationTypeDefinition)
+operationTypeDefinitions :: Parser (NonEmpty Full.OperationTypeDefinition)
 operationTypeDefinitions = braces $ NonEmpty.some operationTypeDefinition
 
-schemaExtension :: Parser SchemaExtension
+schemaExtension :: Parser Full.SchemaExtension
 schemaExtension = extend "schema" "SchemaExtension"
     $ schemaOperationExtension :| [directivesExtension]
   where
-    directivesExtension = SchemaDirectivesExtension
+    directivesExtension = Full.SchemaDirectivesExtension
         <$> NonEmpty.some directive
-    schemaOperationExtension = SchemaOperationExtension
+    schemaOperationExtension = Full.SchemaOperationExtension
         <$> directives
         <*> operationTypeDefinitions
 
-operationTypeDefinition :: Parser OperationTypeDefinition
-operationTypeDefinition = OperationTypeDefinition
+operationTypeDefinition :: Parser Full.OperationTypeDefinition
+operationTypeDefinition = Full.OperationTypeDefinition
     <$> operationType <* colon
     <*> name
     <?> "OperationTypeDefinition"
 
-operationDefinition :: Parser OperationDefinition
+operationDefinition :: Parser Full.OperationDefinition
 operationDefinition = shorthand
     <|> operationDefinition'
     <?> "OperationDefinition"
@@ -353,7 +344,7 @@ operationDefinition = shorthand
     shorthand = do
         location <- getLocation
         selectionSet' <- selectionSet
-        pure $ SelectionSet selectionSet' location
+        pure $ Full.SelectionSet selectionSet' location
     operationDefinition' = do
         location <- getLocation
         operationType' <- operationType
@@ -361,60 +352,74 @@ operationDefinition = shorthand
         variableDefinitions' <- variableDefinitions
         directives' <- directives
         selectionSet' <- selectionSet
-        pure $ OperationDefinition operationType' operationName variableDefinitions' directives' selectionSet' location
+        pure $ Full.OperationDefinition
+            operationType'
+            operationName
+            variableDefinitions'
+            directives'
+            selectionSet'
+            location
 
-operationType :: Parser OperationType
-operationType = Query <$ symbol "query"
-    <|> Mutation <$ symbol "mutation"
-    <|> Subscription <$ symbol "subscription"
+operationType :: Parser Full.OperationType
+operationType = Full.Query <$ symbol "query"
+    <|> Full.Mutation <$ symbol "mutation"
+    <|> Full.Subscription <$ symbol "subscription"
     <?> "OperationType"
 
-selectionSet :: Parser SelectionSet
+selectionSet :: Parser Full.SelectionSet
 selectionSet = braces (NonEmpty.some selection) <?> "SelectionSet"
 
-selectionSetOpt :: Parser SelectionSetOpt
+selectionSetOpt :: Parser Full.SelectionSetOpt
 selectionSetOpt = listOptIn braces selection <?> "SelectionSet"
 
-selection :: Parser Selection
-selection = field
-    <|> try fragmentSpread
-    <|> inlineFragment
+selection :: Parser Full.Selection
+selection = Full.FieldSelection <$> field
+    <|> Full.FragmentSpreadSelection <$> try fragmentSpread
+    <|> Full.InlineFragmentSelection <$> inlineFragment
     <?> "Selection"
 
-field :: Parser Selection
-field = Field
-    <$> optional alias
-    <*> name
-    <*> arguments
-    <*> directives
-    <*> selectionSetOpt
-    <?> "Field"
+field :: Parser Full.Field
+field = label "Field" $ do
+    location <- getLocation
+    alias' <- optional alias
+    name' <- name
+    arguments' <- arguments
+    directives' <- directives
+    selectionSetOpt' <- selectionSetOpt
+    pure $ Full.Field alias' name' arguments' directives' selectionSetOpt' location
 
-alias :: Parser Alias
+alias :: Parser Full.Name
 alias = try (name <* colon) <?> "Alias"
 
-arguments :: Parser [Argument]
+arguments :: Parser [Full.Argument]
 arguments = listOptIn parens argument <?> "Arguments"
 
-argument :: Parser Argument
-argument = Argument <$> name <* colon <*> value <?> "Argument"
+argument :: Parser Full.Argument
+argument = label "Argument" $ do
+    location <- getLocation
+    name' <- name
+    colon
+    value' <- valueNode value
+    pure $ Full.Argument name' value' location
 
-fragmentSpread :: Parser Selection
-fragmentSpread = FragmentSpread
-    <$ spread
-    <*> fragmentName
-    <*> directives
-    <?> "FragmentSpread"
+fragmentSpread :: Parser Full.FragmentSpread
+fragmentSpread = label "FragmentSpread" $ do
+    location <- getLocation
+    _ <- spread
+    fragmentName' <- fragmentName
+    directives' <- directives
+    pure $ Full.FragmentSpread fragmentName' directives' location
 
-inlineFragment :: Parser Selection
-inlineFragment = InlineFragment
-    <$ spread
-    <*> optional typeCondition
-    <*> directives
-    <*> selectionSet
-    <?> "InlineFragment"
+inlineFragment :: Parser Full.InlineFragment
+inlineFragment = label "InlineFragment" $ do
+    location <- getLocation
+    _ <- spread
+    typeCondition' <- optional typeCondition
+    directives' <- directives
+    selectionSet' <- selectionSet
+    pure $ Full.InlineFragment typeCondition' directives' selectionSet' location
 
-fragmentDefinition :: Parser FragmentDefinition
+fragmentDefinition :: Parser Full.FragmentDefinition
 fragmentDefinition =  label "FragmentDefinition" $ do
     location <- getLocation
     _ <- symbol "fragment"
@@ -422,36 +427,42 @@ fragmentDefinition =  label "FragmentDefinition" $ do
     typeCondition' <- typeCondition
     directives' <- directives
     selectionSet' <- selectionSet
-    pure $ FragmentDefinition
+    pure $ Full.FragmentDefinition
         fragmentName' typeCondition' directives' selectionSet' location
 
-fragmentName :: Parser Name
+fragmentName :: Parser Full.Name
 fragmentName = but (symbol "on") *> name <?> "FragmentName"
 
-typeCondition :: Parser TypeCondition
+typeCondition :: Parser Full.TypeCondition
 typeCondition = symbol "on" *> name <?> "TypeCondition"
 
-value :: Parser Value
-value = Variable <$> variable
-    <|> Float <$> try float
-    <|> Int <$> integer
-    <|> Boolean <$> booleanValue
-    <|> Null <$  nullValue
-    <|> String <$> stringValue
-    <|> Enum <$> try enumValue
-    <|> List <$> brackets (some value)
-    <|> Object <$> braces (some $ objectField value)
+valueNode :: forall a. Parser a -> Parser (Full.Node a)
+valueNode valueParser = do
+    location <- getLocation
+    value' <- valueParser
+    pure $ Full.Node value' location
+
+value :: Parser Full.Value
+value = Full.Variable <$> variable
+    <|> Full.Float <$> try float
+    <|> Full.Int <$> integer
+    <|> Full.Boolean <$> booleanValue
+    <|> Full.Null <$  nullValue
+    <|> Full.String <$> stringValue
+    <|> Full.Enum <$> try enumValue
+    <|> Full.List <$> brackets (many $ valueNode value)
+    <|> Full.Object <$> braces (many $ objectField $ valueNode value)
     <?> "Value"
 
-constValue :: Parser ConstValue
-constValue = ConstFloat <$> try float
-    <|> ConstInt <$> integer
-    <|> ConstBoolean <$> booleanValue
-    <|> ConstNull <$ nullValue
-    <|> ConstString <$> stringValue
-    <|> ConstEnum <$> try enumValue
-    <|> ConstList <$> brackets (some constValue)
-    <|> ConstObject <$> braces (some $ objectField constValue)
+constValue :: Parser Full.ConstValue
+constValue = Full.ConstFloat <$> try float
+    <|> Full.ConstInt <$> integer
+    <|> Full.ConstBoolean <$> booleanValue
+    <|> Full.ConstNull <$ nullValue
+    <|> Full.ConstString <$> stringValue
+    <|> Full.ConstEnum <$> try enumValue
+    <|> Full.ConstList <$> brackets (many $ valueNode constValue)
+    <|> Full.ConstObject <$> braces (many $ objectField $ valueNode constValue)
     <?> "Value"
 
 booleanValue :: Parser Bool
@@ -459,7 +470,7 @@ booleanValue = True  <$ symbol "true"
     <|> False <$ symbol "false"
     <?> "BooleanValue"
 
-enumValue :: Parser Name
+enumValue :: Parser Full.Name
 enumValue = but (symbol "true")
     *> but (symbol "false")
     *> but (symbol "null")
@@ -472,51 +483,54 @@ stringValue = blockString <|> string <?> "StringValue"
 nullValue :: Parser Text
 nullValue = symbol "null" <?> "NullValue"
 
-objectField :: Parser a -> Parser (ObjectField a)
-objectField valueParser = ObjectField
-    <$> name
-    <* colon
-    <*> valueParser
-    <?> "ObjectField"
+objectField :: forall a. Parser (Full.Node a) -> Parser (Full.ObjectField a)
+objectField valueParser = label "ObjectField" $ do
+    location <- getLocation
+    fieldName <- name
+    colon
+    fieldValue <- valueParser
+    pure $ Full.ObjectField fieldName fieldValue location
 
-variableDefinitions :: Parser [VariableDefinition]
+variableDefinitions :: Parser [Full.VariableDefinition]
 variableDefinitions = listOptIn parens variableDefinition
     <?> "VariableDefinitions"
 
-variableDefinition :: Parser VariableDefinition
-variableDefinition = VariableDefinition
-    <$> variable
-    <*  colon
-    <*> type'
-    <*> defaultValue
-    <?> "VariableDefinition"
+variableDefinition :: Parser Full.VariableDefinition
+variableDefinition = label "VariableDefinition" $ do
+    location <- getLocation
+    variableName <- variable
+    colon
+    variableType <- type'
+    variableValue <- defaultValue
+    pure $ Full.VariableDefinition variableName variableType variableValue location
 
-variable :: Parser Name
+variable :: Parser Full.Name
 variable = dollar *> name <?> "Variable"
 
-defaultValue :: Parser (Maybe ConstValue)
-defaultValue = optional (equals *> constValue) <?> "DefaultValue"
+defaultValue :: Parser (Maybe (Full.Node Full.ConstValue))
+defaultValue = optional (equals *> valueNode constValue) <?> "DefaultValue"
 
-type' :: Parser Type
-type' = try (TypeNonNull <$> nonNullType)
-    <|> TypeList <$> brackets type'
-    <|> TypeNamed <$> name
+type' :: Parser Full.Type
+type' = try (Full.TypeNonNull <$> nonNullType)
+    <|> Full.TypeList <$> brackets type'
+    <|> Full.TypeNamed <$> name
     <?> "Type"
 
-nonNullType :: Parser NonNullType
-nonNullType = NonNullTypeNamed <$> name <* bang
-    <|> NonNullTypeList  <$> brackets type'  <* bang
+nonNullType :: Parser Full.NonNullType
+nonNullType = Full.NonNullTypeNamed <$> name <* bang
+    <|> Full.NonNullTypeList  <$> brackets type'  <* bang
     <?> "NonNullType"
 
-directives :: Parser [Directive]
+directives :: Parser [Full.Directive]
 directives = many directive <?> "Directives"
 
-directive :: Parser Directive
-directive = Directive
-    <$  at
-    <*> name
-    <*> arguments
-    <?> "Directive"
+directive :: Parser Full.Directive
+directive = label "Directive" $ do
+    location <- getLocation
+    at
+    directiveName <- name
+    directiveArguments <- arguments
+    pure $ Full.Directive directiveName directiveArguments location
 
 listOptIn :: (Parser [a] -> Parser [a]) -> Parser a -> Parser [a]
 listOptIn surround = option [] . surround . some

src/Language/GraphQL/Error.hs

@@ -1,34 +1,29 @@
+{- 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.
 module Language.GraphQL.Error
-    ( parseError
-    , CollectErrsT
-    , Error(..)
-    , Resolution(..)
+    ( Error(..)
+    , Path(..)
     , ResolverException(..)
     , Response(..)
     , ResponseEventStream
-    , addErr
-    , addErrMsg
-    , runCollectErrs
-    , singleError
+    , parseError
     ) where
 
 import Conduit
 import Control.Exception (Exception(..))
-import Control.Monad.Trans.State (StateT, modify, runStateT)
-import Data.HashMap.Strict (HashMap)
 import Data.Sequence (Seq(..), (|>))
 import qualified Data.Sequence as Seq
 import Data.Text (Text)
 import qualified Data.Text as Text
-import Language.GraphQL.AST (Location(..), Name)
+import Language.GraphQL.AST (Location(..))
 import Language.GraphQL.Execute.Coerce
-import Language.GraphQL.Type.Schema
 import Prelude hiding (null)
 import Text.Megaparsec
     ( ParseErrorBundle(..)
@@ -40,12 +35,6 @@ import Text.Megaparsec
     , unPos
     )
 
--- | Executor context.
-data Resolution m = Resolution
-    { errors :: Seq Error
-    , types :: HashMap Name (Type m)
-    }
-
 -- | Wraps a parse error into a list of errors.
 parseError :: (Applicative f, Serialize a)
     => ParseErrorBundle Text Void
@@ -57,6 +46,7 @@ parseError ParseErrorBundle{..}  =
     errorObject s SourcePos{..} = Error
         { message = Text.pack $ init $ parseErrorTextPretty s
         , locations = [Location (unPos' sourceLine) (unPos' sourceColumn)]
+        , path = []
         }
     unPos' = fromIntegral . unPos
     go (result, state) x =
@@ -64,32 +54,20 @@ 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
+-- whether a null result is intentional or caused by a runtime error.
+data Path
+    = Segment Text -- ^ Field name.
+    | Index Int -- ^ List index if a field returned a list.
+    deriving (Eq, Show)
 
 -- | @GraphQL@ error.
 data Error = Error
     { message :: Text
     , locations :: [Location]
+    , path :: [Path]
     } deriving (Eq, Show)
 
 -- | The server\'s response describes the result of executing the requested
@@ -113,14 +91,3 @@ instance Show ResolverException where
     show (ResolverException e) = show e
 
 instance Exception ResolverException
-
--- | Runs the given query computation, but collects the errors into an error
--- list, which is then sent back with the data.
-runCollectErrs :: (Monad m, Serialize a)
-    => HashMap Name (Type m)
-    -> CollectErrsT m a
-    -> m (Response a)
-runCollectErrs types' res = do
-    (dat, Resolution{..}) <- runStateT res
-        $ Resolution{ errors = Seq.empty, types = types' }
-    pure $ Response dat errors

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,221 @@ 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 qualified Data.Vector as Vector
 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 Language.GraphQL.Error
-import qualified Language.GraphQL.Type.Definition as Definition
+import qualified Language.GraphQL.Type.In as In
 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)
+import Language.GraphQL.AST.Document (showVariableName)
+
+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
+
+operationNameErrorText :: Text
+operationNameErrorText = Text.unlines
+    [ "Named operations must be provided with the name of the desired operation."
+    , "See https://spec.graphql.org/June2018/#sec-Language.Document description."
+    ]
+
+queryError :: QueryError -> Error
+queryError OperationNameRequired =
+    let queryErrorMessage = "Operation name is required. " <> operationNameErrorText
+    in Error{ message = queryErrorMessage, locations = [], path = [] }
+queryError (OperationNotFound operationName) =
+    let queryErrorMessage = Text.unlines
+            [ Text.concat
+              [ "Operation \""
+              , Text.pack operationName
+              , "\" is not found in the named operations you've provided. "
+              ]
+            , operationNameErrorText
+            ]
+     in Error{ message = queryErrorMessage, locations = [], path = [] }
+queryError (CoercionError variableDefinition) =
+    let (Full.VariableDefinition _ _ _ location) = variableDefinition
+        queryErrorMessage = Text.concat
+            [ "Failed to coerce the variable "
+            , Text.pack $ Full.showVariable variableDefinition
+            , "."
+            ]
+     in Error{ message = queryErrorMessage, locations = [location], path = [] }
+queryError (UnknownInputType variableDefinition) =
+    let Full.VariableDefinition _ variableTypeName _ location = variableDefinition
+        queryErrorMessage = Text.concat
+            [ "Variable "
+            , Text.pack $ showVariableName variableDefinition
+            , " 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 +240,486 @@ 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.
-    -> Document -- @GraphQL@ document.
+    -> HashMap Full.Name a -- ^ Variable substitution function.
+    -> Full.Document -- @GraphQL@ document.
     -> m (Either (ResponseEventStream m b) (Response b))
-execute schema operationName subs document =
-    case Transform.document schema operationName subs document of
-        Left queryError -> pure
-            $ Right
-            $ singleError
-            $ Transform.queryError queryError
-        Right transformed -> executeRequest transformed
+execute schema' operationName subs document' =
+    executeRequest schema' document' (Text.unpack <$> operationName) subs
 
-executeRequest :: (MonadCatch m, Serialize a)
-    => Transform.Document m
+executeRequest :: (MonadCatch m, Serialize a, VariableValue b)
+    => Schema m
+    -> Full.Document
+    -> Maybe String
+    -> HashMap Full.Name b
     -> m (Either (ResponseEventStream m a) (Response a))
-executeRequest (Transform.Document types' rootObjectType operation)
-    | (Transform.Query _ fields) <- operation =
-        Right <$> executeOperation types' rootObjectType fields
-    | (Transform.Mutation _ fields) <- operation =
-        Right <$> executeOperation types' rootObjectType fields
-    | (Transform.Subscription _ fields) <- operation
-        = either (Right . singleError) Left
-        <$> Subscribe.subscribe types' rootObjectType fields
+executeRequest schema sourceDocument operationName variableValues = do
+    operationAndVariables <- sequence buildOperation
+    case operationAndVariables of
+        Left queryError' -> pure
+            $ Right
+            $ Response null $ pure $ queryError queryError'
+        Right operation
+            | 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
--- and mutations yet.
-executeOperation :: (MonadCatch m, Serialize a)
-    => HashMap Name (Type m)
+rightErrorResponse :: Serialize b => forall a. Error -> Either a (Response b)
+rightErrorResponse = Right . Response null . pure
+
+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
+    fieldErrorPath = fieldsSegment fields : errorPath
+    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 newError = constructError e errorLocation fieldErrorPath
+         in if Out.isNonNullType fieldType
+             then throwM $ FieldException errorLocation fieldErrorPath 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 fieldErrorPath 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
+
+-- https://spec.graphql.org/October2021/#sec-Value-Completion
+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 Vector.empty list >>= coerceResult outputType . List . Vector.toList
+  where
+    go accumulator listItem =
+        let updatedPath = Index (Vector.length accumulator) : errorPath
+         in Vector.snoc accumulator
+            <$> completeValue listType fields updatedPath listItem
+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 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 =
+      coerceInputLiteral inputType $ extractArgumentValue transform
+
+    extractArgumentValue (Transform.Int integer) = Type.Int integer
+    extractArgumentValue (Transform.Boolean boolean) = Type.Boolean boolean
+    extractArgumentValue (Transform.String string) = Type.String string
+    extractArgumentValue (Transform.Float float) = Type.Float float
+    extractArgumentValue (Transform.Enum enum) = Type.Enum enum
+    extractArgumentValue Transform.Null = Type.Null
+    extractArgumentValue (Transform.List list) =
+      Type.List $ extractArgumentValue <$> list
+    extractArgumentValue (Transform.Object object) =
+      Type.Object $ extractArgumentValue <$> object
+    extractArgumentValue (Transform.Variable variable) = variable
+
+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 =
-    runCollectErrs types' $ executeSelectionSet Definition.Null objectType fields
+executeSubscriptionEvent types' objectType fields initialValue = do
+    (data', errors) <- runWriterT
+        $ flip runReaderT types'
+        $ runExecutorT
+        $ catch (executeSelectionSet fields objectType initialValue [])
+        handleException
+    pure $ Response data' errors

src/Language/GraphQL/Execute/Coerce.hs

@@ -15,18 +15,17 @@ module Language.GraphQL.Execute.Coerce
     , matchFieldValues
     ) where
 
-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
 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
@@ -60,20 +59,13 @@ class VariableValue a where
         -> a -- ^ Variable value being coerced.
         -> Maybe Type.Value -- ^ Coerced value on success, 'Nothing' otherwise.
 
-instance VariableValue Aeson.Value where
-    coerceVariableValue _ Aeson.Null = Just Type.Null
-    coerceVariableValue (In.ScalarBaseType scalarType) value
-        | (Aeson.String stringValue) <- value = Just $ Type.String stringValue
-        | (Aeson.Bool booleanValue) <- value = Just $ Type.Boolean booleanValue
-        | (Aeson.Number numberValue) <- value
-        , (Type.ScalarType "Float" _) <- scalarType =
-            Just $ Type.Float $ toRealFloat numberValue
-        | (Aeson.Number numberValue) <- value = -- ID or Int
-            Type.Int <$> toBoundedInteger numberValue
-    coerceVariableValue (In.EnumBaseType _) (Aeson.String stringValue) =
+instance VariableValue Type.Value where
+    coerceVariableValue _ Type.Null = Just Type.Null
+    coerceVariableValue (In.ScalarBaseType _) value = Just value
+    coerceVariableValue (In.EnumBaseType _) (Type.Enum stringValue) =
         Just $ Type.Enum stringValue
     coerceVariableValue (In.InputObjectBaseType objectType) value
-        | (Aeson.Object objectValue) <- value = do
+        | (Type.Object objectValue) <- value = do
             let (In.InputObjectType _ _ inputFields) = objectType
             (newObjectValue, resultMap) <- foldWithKey objectValue inputFields
             if HashMap.null newObjectValue
@@ -93,14 +85,9 @@ instance VariableValue Aeson.Value where
                         pure (newObjectValue, insert coerced)
                     Nothing -> Just (objectValue, resultMap)
     coerceVariableValue (In.ListBaseType listType) value
-        | (Aeson.Array arrayValue) <- value =
-            Type.List <$> foldr foldVector (Just []) arrayValue
+        | (Type.List arrayValue) <- value =
+            Type.List <$> traverse (coerceVariableValue listType) arrayValue
         | otherwise = coerceVariableValue listType value
-      where
-        foldVector _ Nothing = Nothing
-        foldVector variableValue (Just list) = do
-            coerced <- coerceVariableValue listType variableValue
-            pure $ coerced : list 
     coerceVariableValue _ _ = Nothing
 
 -- | Looks up a value by name in the given map, coerces it and inserts into the
@@ -209,26 +196,29 @@ 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
     fromString = String . fromString
 
-instance Serialize Aeson.Value where
+instance Serialize Type.Value where
+    null = Type.Null
     serialize (Out.ScalarBaseType scalarType) value
         | Type.ScalarType "Int" _ <- scalarType
-        , Int int <- value = Just $ Aeson.toJSON int
+        , Int int <- value = Just $ Type.Int int
         | Type.ScalarType "Float" _ <- scalarType
-        , Float float <- value = Just $ Aeson.toJSON float
+        , Float float <- value = Just $ Type.Float float
         | Type.ScalarType "String" _ <- scalarType
-        , String string <- value = Just $ Aeson.String string
+        , String string <- value = Just $ Type.String string
         | Type.ScalarType "ID" _ <- scalarType
-        , String string <- value = Just $ Aeson.String string
+        , String string <- value = Just $ Type.String string
         | Type.ScalarType "Boolean" _ <- scalarType
-        , 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
+        , Boolean boolean <- value = Just $ Type.Boolean boolean
+    serialize _ (Enum enum) = Just $ Type.Enum enum
+    serialize _ (List list) = Just $ Type.List list
+    serialize _ (Object object) = Just
+        $ Type.Object
+        $ HashMap.fromList
+        $ OrderedMap.toList object
     serialize _ _ = Nothing
-    null = Aeson.Null

src/Language/GraphQL/Execute/Execution.hs

@@ -1,217 +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 Language.GraphQL.Type.Internal
-import Language.GraphQL.Type.Schema
-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
-        , 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
-    => 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 (ObjectType objectType) ->
-                if 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 "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 = AbstractInterfaceType interfaceType
-        concreteType <- resolveAbstractType abstractType objectMap
-        case concreteType of
-            Just objectType -> executeSelectionSet result objectType
-                $ mergeSelectionSets fields
-            Nothing -> addErrMsg "Value completion failed."
-completeValue (Out.UnionBaseType unionType) fields result
-    | Type.Object objectMap <- result = do
-        let abstractType = AbstractUnionType unionType
-        concreteType <- resolveAbstractType abstractType objectMap
-        case concreteType of
-            Just objectType -> executeSelectionSet result objectType
-                $ mergeSelectionSets fields
-            Nothing -> addErrMsg "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,414 +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.Trans.Class (lift)
-import Control.Monad.Trans.State (State, evalStateT, gets, modify)
-import Data.Foldable (find)
-import Data.Functor.Identity (Identity(..))
+import Control.Monad (foldM)
+import Control.Monad.Catch (MonadCatch(..), MonadThrow(..))
+import Control.Monad.Trans.Class (MonadTrans(..))
+import Control.Monad.Trans.Reader (ReaderT(..), local)
+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.NonEmpty (NonEmpty(..))
+import Data.List (intercalate)
 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 Language.GraphQL.AST (Name)
-import qualified Language.GraphQL.Execute.Coerce as Coerce
-import qualified Language.GraphQL.Type.Definition as Definition
+import qualified Language.GraphQL.AST.Document as Full
+import Language.GraphQL.Type.Schema (Type)
 import qualified Language.GraphQL.Type as Type
-import qualified Language.GraphQL.Type.In as In
-import Language.GraphQL.Type.Internal
-import qualified Language.GraphQL.Type.Out as Out
-import Language.GraphQL.Type.Schema
+import qualified Language.GraphQL.Type.Definition as Definition
+import qualified Language.GraphQL.Type.Internal as Type
+import Numeric (showFloat)
 
 -- | Associates a fragment name with a list of 'Field's.
 data Replacement m = Replacement
-    { fragments :: HashMap Full.Name (Fragment m)
-    , fragmentDefinitions :: FragmentDefinitions
-    , variableValues :: Type.Subs
+    { variableValues :: Type.Subs
+    , fragmentDefinitions :: HashMap Full.Name Full.FragmentDefinition
+    , visitedFragments :: HashSet Full.Name
     , 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.
-data Fragment m
-    = Fragment (CompositeType m) (Seq (Selection m))
+instance Functor m => Functor (TransformT m) where
+    fmap f = TransformT . fmap f . runTransformT
 
--- | Single selection element.
-data Selection m
-    = SelectionFragment (Fragment m)
-    | SelectionField (Field m)
+instance Applicative m => Applicative (TransformT m) where
+    pure = TransformT . pure
+    TransformT f <*> TransformT x = TransformT $ f <*> x
+
+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))
-    | Mutation (Maybe Text) (Seq (Selection m))
-    | Subscription (Maybe Text) (Seq (Selection m))
+    = Operation Full.OperationType (Seq (Selection m)) Full.Location
+
+-- | 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 (Type m)) (Out.ObjectType m) (Operation m)
-
-data OperationDefinition = OperationDefinition
-    Full.OperationType
     (Maybe Full.Name)
-    [Full.VariableDefinition]
-    [Full.Directive]
-    Full.SelectionSet
+    Full.Name
+    (HashMap Full.Name (Full.Node Input))
+    (Seq (Selection m))
+    Full.Location
 
--- | Query error types.
-data QueryError
-    = OperationNotFound Text
-    | OperationNameRequired
-    | CoercionError
-    | TransformationError
-    | EmptyDocument
-    | UnsupportedRootOperation
+data Fragment m = Fragment
+    (Type.CompositeType m) (Seq (Selection m)) Full.Location
 
 data Input
-    = Int Int32
+    = Variable Type.Value
+    | Int Int32
     | Float Double
     | String Text
     | Boolean Bool
     | Null
-    | Enum Name
-    | List [Type.Value]
-    | Object (HashMap Name Input)
-    | Variable Type.Value
-    deriving (Eq, Show)
+    | Enum Full.Name
+    | List [Input]
+    | Object (HashMap Full.Name Input)
+    deriving Eq
 
-queryError :: QueryError -> Text
-queryError (OperationNotFound operationName) = Text.unwords
-    ["Operation", operationName, "couldn't be found in the document."]
-queryError OperationNameRequired = "Missing operation name."
-queryError CoercionError = "Coercion error."
-queryError TransformationError = "Schema transformation error."
-queryError EmptyDocument =
-    "The document doesn't contain any executable operations."
-queryError UnsupportedRootOperation =
-    "Root operation type couldn't be found in the schema."
+instance Show Input 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 . Full.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
+    show variableValue = show variableValue
 
-getOperation
-    :: Maybe Full.Name
-    -> NonEmpty OperationDefinition
-    -> Either QueryError OperationDefinition
-getOperation Nothing (operation' :| []) = pure operation'
-getOperation Nothing _ = Left OperationNameRequired
-getOperation (Just operationName) operations
-    | Just operation' <- find matchingName operations = pure operation'
-    | otherwise = Left $ OperationNotFound operationName
+-- | Extracts operations and fragment definitions of the document.
+document :: Full.Document
+    -> ([Full.OperationDefinition], HashMap Full.Name Full.FragmentDefinition)
+document = foldr filterOperation ([], HashMap.empty)
   where
-    matchingName (OperationDefinition _ name _ _ _) =
-        name == Just operationName
-
-lookupInputType
-    :: Full.Type
-    -> HashMap.HashMap Full.Name (Type m)
-    -> Maybe In.Type
-lookupInputType (Full.TypeNamed name) types =
-    case HashMap.lookup name types of
-        Just (ScalarType scalarType) ->
-            Just $ In.NamedScalarType scalarType
-        Just (EnumType enumType) ->
-            Just $ In.NamedEnumType enumType
-        Just (InputObjectType objectType) ->
-            Just $ In.NamedInputObjectType objectType
-        _ -> Nothing
-lookupInputType (Full.TypeList list) types
-    = In.ListType
-    <$> lookupInputType list types
-lookupInputType (Full.TypeNonNull (Full.NonNullTypeNamed nonNull)) types  =
-    case HashMap.lookup nonNull types of
-        Just (ScalarType scalarType) ->
-            Just $ In.NonNullScalarType scalarType
-        Just (EnumType enumType) ->
-            Just $ In.NonNullEnumType enumType
-        Just (InputObjectType objectType) ->
-            Just $ In.NonNullInputObjectType objectType
-        _ -> Nothing
-lookupInputType (Full.TypeNonNull (Full.NonNullTypeList nonNull)) types
-    = In.NonNullListType
-    <$> lookupInputType nonNull types
-
-coerceVariableValues :: Coerce.VariableValue a
-    => forall m
-    . HashMap Full.Name (Type m)
-    -> OperationDefinition
-    -> 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 <$> defaultValue
-        variableType <- 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 key value') = (key, constValue value')
+    filterOperation (Full.ExecutableDefinition executableDefinition) accumulator
+        | Full.DefinitionOperation operationDefinition' <- executableDefinition =
+            first (operationDefinition' :) accumulator
+        | Full.DefinitionFragment fragmentDefinition <- executableDefinition
+        , Full.FragmentDefinition fragmentName _ _ _ _ <- fragmentDefinition =
+            HashMap.insert fragmentName fragmentDefinition <$> accumulator
+    filterOperation _ accumulator = accumulator -- Type system definitions.
 
 -- | Rewrites the original syntax tree into an intermediate representation used
--- for query execution.
-document :: Coerce.VariableValue a
-    => forall m
-    . Schema m
-    -> Maybe Full.Name
+-- for the query execution.
+transform :: Monad m => Full.OperationDefinition -> TransformT m (Operation m)
+transform (Full.OperationDefinition operationType _ _ _ selectionSet' operationLocation) = do
+    transformedSelections <- selectionSet selectionSet'
+    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
-    -> Either QueryError (Document m)
-document schema operationName subs ast = do
-    let referencedTypes = collectReferencedTypes schema
+    -> HashMap Full.Name a
+insertIfGiven name (Just v) = HashMap.insert name v
+insertIfGiven _ _ = id
 
-    (operations, fragmentTable) <- defragment ast
-    chosenOperation <- getOperation operationName operations
-    coercedValues <- coerceVariableValues referencedTypes chosenOperation subs
+node :: Monad m => Full.Node Full.Value -> TransformT m (Maybe (Full.Node Input))
+node Full.Node{node = node', ..} =
+    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 (query schema)
-                $ operation chosenOperation replacement
-        OperationDefinition Full.Mutation _ _ _ _
-            | Just mutationType <- mutation schema ->
-                pure $ Document referencedTypes mutationType
-                    $ operation chosenOperation replacement
-        OperationDefinition Full.Subscription _ _ _ _
-            | Just subscriptionType <- 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.Field alias name arguments' directives' selections) =
-    maybe (Left mempty) (Right . SelectionField) <$> 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' value') =
-        inputField arguments name' value'
-
-selection (Full.FragmentSpread name directives') =
-    maybe (Left mempty) (Right . SelectionFragment) <$> 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
-selection (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 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 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 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 name value') = (name,) <$> value 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 name value') =
-        inputField resultMap name 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 $ flip any ['\n', '\r'] . (==)
+    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(..))
+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
@@ -13,6 +18,8 @@ module Language.GraphQL.Type.Definition
     , float
     , id
     , int
+    , showNonNullType
+    , showNonNullListType
     , selection
     , string
     ) where
@@ -20,9 +27,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 +45,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 +93,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 +106,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)
 
@@ -173,3 +209,11 @@ include = handle include'
             (Just (Boolean True)) -> Include directive'
             _ -> Skip
     include' directive' = Continue directive'
+
+showNonNullType :: Show a => a -> String
+showNonNullType = (++ "!") . show
+
+showNonNullListType :: Show a => a -> String
+showNonNullListType listType =
+    let representation = show listType
+     in concat ["[", representation, "]!"]

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.
@@ -11,6 +12,7 @@
 -- with 'Language.GraphQL.Type.Out'.
 module Language.GraphQL.Type.In
     ( Argument(..)
+    , Arguments
     , InputField(..)
     , InputObjectType(..)
     , Type(..)
@@ -23,11 +25,12 @@ 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 Language.GraphQL.Type.Definition
+import qualified Language.GraphQL.Type.Definition as Definition
 
 -- | Single field of an 'InputObjectType'.
-data InputField = InputField (Maybe Text) Type (Maybe Value)
+data InputField = InputField (Maybe Text) Type (Maybe Definition.Value)
 
 -- | Input object type definition.
 --
@@ -39,31 +42,48 @@ 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
 -- type can wrap other wrapping or named types. Wrapping types are lists and
 -- Non-Null types (named types are nullable by default).
 data Type
-    = NamedScalarType ScalarType
-    | NamedEnumType EnumType
+    = NamedScalarType Definition.ScalarType
+    | NamedEnumType Definition.EnumType
     | NamedInputObjectType InputObjectType
     | ListType Type
-    | NonNullScalarType ScalarType
-    | NonNullEnumType EnumType
+    | NonNullScalarType Definition.ScalarType
+    | NonNullEnumType Definition.EnumType
     | NonNullInputObjectType InputObjectType
     | 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) = Definition.showNonNullType scalarType
+    show (NonNullEnumType enumType) = Definition.showNonNullType enumType
+    show (NonNullInputObjectType inputObjectType) =
+        Definition.showNonNullType inputObjectType
+    show (NonNullListType baseType) = Definition.showNonNullListType baseType
+
 -- | Field argument definition.
-data Argument = Argument (Maybe Text) Type (Maybe Value)
+data Argument = Argument (Maybe Text) Type (Maybe Definition.Value)
+
+-- | Field argument definitions.
+type Arguments = HashMap Name Argument
 
 -- | Matches either 'NamedScalarType' or 'NonNullScalarType'.
-pattern ScalarBaseType :: ScalarType -> Type
+pattern ScalarBaseType :: Definition.ScalarType -> Type
 pattern ScalarBaseType scalarType <- (isScalarType -> Just scalarType)
 
 -- | Matches either 'NamedEnumType' or 'NonNullEnumType'.
-pattern EnumBaseType :: EnumType -> Type
+pattern EnumBaseType :: Definition.EnumType -> Type
 pattern EnumBaseType enumType <- (isEnumType -> Just enumType)
 
 -- | Matches either 'NamedInputObjectType' or 'NonNullInputObjectType'.
@@ -76,7 +96,7 @@ pattern ListBaseType listType <- (isListType -> Just listType)
 
 {-# COMPLETE EnumBaseType, ListBaseType, InputObjectBaseType, ScalarBaseType #-}
 
-isScalarType :: Type -> Maybe ScalarType
+isScalarType :: Type -> Maybe Definition.ScalarType
 isScalarType (NamedScalarType inputType) = Just inputType
 isScalarType (NonNullScalarType inputType) = Just inputType
 isScalarType _ = Nothing
@@ -86,7 +106,7 @@ isInputObjectType (NamedInputObjectType inputType) = Just inputType
 isInputObjectType (NonNullInputObjectType inputType) = Just inputType
 isInputObjectType _ = Nothing
 
-isEnumType :: Type -> Maybe EnumType
+isEnumType :: Type -> Maybe Definition.EnumType
 isEnumType (NamedEnumType inputType) = Just inputType
 isEnumType (NonNullEnumType inputType) = Just inputType
 isEnumType _ = Nothing

src/Language/GraphQL/Type/Internal.hs

@@ -3,23 +3,96 @@
    obtain one at https://mozilla.org/MPL/2.0/. -}
 
 {-# LANGUAGE ExplicitForAll #-}
+{-# LANGUAGE LambdaCase #-}
 
 module Language.GraphQL.Type.Internal
     ( AbstractType(..)
     , CompositeType(..)
-    , collectReferencedTypes
+    , Directive(..)
+    , Directives
+    , Schema(..)
+    , Type(..)
+    , description
+    , directives
     , doesFragmentTypeApply
+    , implementations
     , instanceOf
+    , lookupCompositeField
+    , lookupInputType
     , lookupTypeCondition
+    , lookupTypeField
+    , mutation
+    , outToComposite
+    , subscription
+    , query
+    , types
     ) where
 
 import Data.HashMap.Strict (HashMap)
 import qualified Data.HashMap.Strict as HashMap
-import Language.GraphQL.AST (Name)
+import Data.Text (Text)
+import qualified Language.GraphQL.AST as Full
+import Language.GraphQL.AST.DirectiveLocation (DirectiveLocation)
 import qualified Language.GraphQL.Type.Definition as Definition
 import qualified Language.GraphQL.Type.In as In
 import qualified Language.GraphQL.Type.Out as Out
-import Language.GraphQL.Type.Schema
+
+-- | These are all of the possible kinds of types.
+data Type m
+    = ScalarType Definition.ScalarType
+    | EnumType Definition.EnumType
+    | ObjectType (Out.ObjectType m)
+    | InputObjectType In.InputObjectType
+    | InterfaceType (Out.InterfaceType m)
+    | UnionType (Out.UnionType m)
+    deriving Eq
+
+-- | Directive definition.
+data Directive = Directive (Maybe Text) [DirectiveLocation] In.Arguments
+
+-- | Directive definitions.
+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.
+data Schema m = Schema
+    (Maybe Text) -- ^ Description.
+    (Out.ObjectType m) -- ^ Query.
+    (Maybe (Out.ObjectType m)) -- ^ Mutation.
+    (Maybe (Out.ObjectType m)) -- ^ Subscription.
+    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'
+
+-- | Schema mutation type.
+mutation :: forall m. Schema m -> Maybe (Out.ObjectType m)
+mutation (Schema _ _ mutation' _ _ _ _) = mutation'
+
+-- | Schema subscription type.
+subscription :: forall m. Schema m -> Maybe (Out.ObjectType m)
+subscription (Schema _ _ _ subscription' _ _ _) = subscription'
+
+-- | Schema directive definitions.
+directives :: forall m. Schema m -> Directives
+directives (Schema _ _ _ _ directives' _ _) = directives'
+
+-- | Types referenced by the schema.
+types :: forall m. Schema m -> HashMap Full.Name (Type m)
+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
@@ -34,65 +107,6 @@ data AbstractType m
     | AbstractInterfaceType (Out.InterfaceType m)
     deriving Eq
 
--- | Traverses the schema and finds all referenced types.
-collectReferencedTypes :: forall m. Schema m -> HashMap Name (Type m)
-collectReferencedTypes schema =
-    let queryTypes = traverseObjectType (query schema) HashMap.empty
-     in maybe queryTypes (`traverseObjectType` queryTypes) $ mutation schema
-  where
-    collect traverser typeName element foundTypes
-        | HashMap.member typeName foundTypes = foundTypes
-        | otherwise = traverser $ HashMap.insert typeName element foundTypes
-    visitFields (Out.Field _ outputType arguments) foundTypes
-        = traverseOutputType outputType
-        $ foldr visitArguments foundTypes arguments
-    visitArguments (In.Argument _ inputType _) = traverseInputType inputType
-    visitInputFields (In.InputField _ inputType _) = traverseInputType inputType
-    getField (Out.ValueResolver field _) = field
-    getField (Out.EventStreamResolver field _ _) = field
-    traverseInputType (In.InputObjectBaseType objectType) =
-        let (In.InputObjectType typeName _ inputFields) = objectType
-            element = InputObjectType objectType
-            traverser = flip (foldr visitInputFields) inputFields
-         in collect traverser typeName element
-    traverseInputType (In.ListBaseType listType) =
-        traverseInputType listType
-    traverseInputType (In.ScalarBaseType scalarType) =
-        let (Definition.ScalarType typeName _) = scalarType
-         in collect Prelude.id typeName (ScalarType scalarType)
-    traverseInputType (In.EnumBaseType enumType) =
-        let (Definition.EnumType typeName _ _) = enumType
-         in collect Prelude.id typeName (EnumType enumType)
-    traverseOutputType (Out.ObjectBaseType objectType) =
-        traverseObjectType objectType
-    traverseOutputType (Out.InterfaceBaseType interfaceType) =
-        traverseInterfaceType interfaceType
-    traverseOutputType (Out.UnionBaseType unionType) =
-        let (Out.UnionType typeName _ types) = unionType
-            traverser = flip (foldr traverseObjectType) types
-         in collect traverser typeName (UnionType unionType)
-    traverseOutputType (Out.ListBaseType listType) =
-        traverseOutputType listType
-    traverseOutputType (Out.ScalarBaseType scalarType) =
-        let (Definition.ScalarType typeName _) = scalarType
-         in collect Prelude.id typeName (ScalarType scalarType)
-    traverseOutputType (Out.EnumBaseType enumType) =
-        let (Definition.EnumType typeName _ _) = enumType
-         in collect Prelude.id typeName (EnumType enumType)
-    traverseObjectType objectType foundTypes =
-        let (Out.ObjectType typeName _ interfaces fields) = objectType
-            element = ObjectType objectType
-            traverser = polymorphicTraverser interfaces (getField <$> fields)
-         in collect traverser typeName element foundTypes
-    traverseInterfaceType interfaceType foundTypes =
-        let (Out.InterfaceType typeName _ interfaces fields) = interfaceType
-            element = InterfaceType interfaceType
-            traverser = polymorphicTraverser interfaces fields
-         in collect traverser typeName element foundTypes
-    polymorphicTraverser interfaces fields
-        = flip (foldr visitFields) fields
-        . flip (foldr traverseInterfaceType) interfaces
-
 doesFragmentTypeApply :: forall m
     . CompositeType m
     -> Out.ObjectType m
@@ -118,13 +132,69 @@ instanceOf objectType (AbstractUnionType unionType) =
     go unionMemberType acc = acc || objectType == unionMemberType
 
 lookupTypeCondition :: forall m
-    . Name
-    -> HashMap Name (Type m)
+    . Full.Name
+    -> HashMap Full.Name (Type m)
     -> Maybe (CompositeType m)
 lookupTypeCondition type' types' =
     case HashMap.lookup type' types' of
-        Just (ObjectType objectType) -> Just $ CompositeObjectType objectType
+        Just (ObjectType objectType) ->
+            Just $ CompositeObjectType objectType
         Just (UnionType unionType) -> Just $ CompositeUnionType unionType
         Just (InterfaceType interfaceType) ->
             Just $ CompositeInterfaceType interfaceType
         _ -> Nothing
+
+lookupInputType :: Full.Type -> HashMap Full.Name (Type m) -> Maybe In.Type
+lookupInputType (Full.TypeNamed name) types' =
+    case HashMap.lookup name types' of
+        Just (ScalarType scalarType) ->
+            Just $ In.NamedScalarType scalarType
+        Just (EnumType enumType) ->
+            Just $ In.NamedEnumType enumType
+        Just (InputObjectType objectType) ->
+            Just $ In.NamedInputObjectType objectType
+        _ -> Nothing
+lookupInputType (Full.TypeList list) types'
+    = In.ListType
+    <$> lookupInputType list types'
+lookupInputType (Full.TypeNonNull (Full.NonNullTypeNamed nonNull)) types' =
+    case HashMap.lookup nonNull types' of
+        Just (ScalarType scalarType) ->
+            Just $ In.NonNullScalarType scalarType
+        Just (EnumType enumType) ->
+            Just $ In.NonNullEnumType enumType
+        Just (InputObjectType objectType) ->
+            Just $ In.NonNullInputObjectType objectType
+        _ -> Nothing
+lookupInputType (Full.TypeNonNull (Full.NonNullTypeList nonNull)) types'
+    = In.NonNullListType
+    <$> lookupInputType nonNull types'
+
+lookupTypeField :: forall a. Full.Name -> Out.Type a -> Maybe (Out.Field a)
+lookupTypeField fieldName outputType =
+    outToComposite outputType >>= lookupCompositeField fieldName
+
+lookupCompositeField :: forall a
+    . Full.Name
+    -> CompositeType a
+    -> Maybe (Out.Field a)
+lookupCompositeField fieldName = \case
+    CompositeObjectType objectType -> objectChild objectType
+    CompositeInterfaceType interfaceType -> interfaceChild interfaceType
+    _ -> Nothing
+  where
+    objectChild (Out.ObjectType _ _ _ resolvers) =
+        resolverType <$> HashMap.lookup fieldName resolvers
+    interfaceChild (Out.InterfaceType _ _ _ fields) =
+        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,11 +79,14 @@ 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.
     (Type m) -- ^ Field type.
-    (HashMap Name In.Argument) -- ^ Arguments.
+    In.Arguments -- ^ Arguments.
 
 -- | These types may be used as output types as the result of fields.
 --
@@ -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) = showNonNullType scalarType
+    show (NonNullEnumType enumType) = showNonNullType enumType
+    show (NonNullObjectType inputObjectType) = showNonNullType inputObjectType
+    show (NonNullInterfaceType interfaceType) = showNonNullType interfaceType
+    show (NonNullUnionType unionType) = showNonNullType unionType
+    show (NonNullListType baseType) = showNonNullListType 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

@@ -2,36 +2,208 @@
    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 #-}
+
 -- | This module provides a representation of a @GraphQL@ Schema in addition to
 -- functions for defining and manipulating schemas.
 module Language.GraphQL.Type.Schema
-    ( Schema(..)
-    , Type(..)
+    ( 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
+import Language.GraphQL.Type.Internal
+    ( Directive(..)
+    , Directives
+    , Schema
+    , Type(..)
+    , description
+    , directives
+    , implementations
+    , mutation
+    , subscription
+    , query
+    , types
+    )
 import qualified Language.GraphQL.Type.Definition as Definition
+import qualified Language.GraphQL.Type.Internal as Internal
 import qualified Language.GraphQL.Type.In as In
 import qualified Language.GraphQL.Type.Out as Out
 
--- | These are all of the possible kinds of types.
-data Type m
-    = ScalarType Definition.ScalarType
-    | EnumType Definition.EnumType
-    | ObjectType (Out.ObjectType m)
-    | InputObjectType In.InputObjectType
-    | InterfaceType (Out.InterfaceType m)
-    | UnionType (Out.UnionType m)
-    deriving Eq
-
--- | 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.
+-- | 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.
-data Schema m = Schema
-    { query :: Out.ObjectType m
-    , mutation :: Maybe (Out.ObjectType m)
-    , subscription :: Maybe (Out.ObjectType m)
-    }
+-- __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 =
+    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
+    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)
+        , ("include", includeDirective)
+        , ("deprecated", deprecatedDirective)
+        ]
+    includeDirective =
+        Directive includeDescription skipIncludeLocations includeArguments
+    includeArguments = HashMap.singleton "if"
+        $ In.Argument (Just "Included when true.") ifType Nothing
+    includeDescription = Just
+        "Directs the executor to include this field or fragment only when the \
+        \`if` argument is true."
+    skipDirective = Directive skipDescription skipIncludeLocations skipArguments
+    skipArguments = HashMap.singleton "if"
+        $ In.Argument (Just "skipped when true.") ifType Nothing
+    ifType = In.NonNullScalarType Definition.boolean
+    skipDescription = Just
+        "Directs the executor to skip this field or fragment when the `if` \
+        \argument is true."
+    skipIncludeLocations =
+        [ ExecutableDirectiveLocation DirectiveLocation.Field
+        , ExecutableDirectiveLocation DirectiveLocation.FragmentSpread
+        , ExecutableDirectiveLocation DirectiveLocation.InlineFragment
+        ]
+    deprecatedDirective =
+        Directive deprecatedDescription deprecatedLocations deprecatedArguments
+    reasonDescription = Just
+        "Explains why this element was deprecated, usually also including a \
+        \suggestion for how to access supported similar data. Formatted using \
+        \the Markdown syntax, as specified by \
+        \[CommonMark](https://commonmark.org/).'"
+    deprecatedArguments = HashMap.singleton "reason"
+        $ In.Argument reasonDescription reasonType
+        $ Just "No longer supported"
+    reasonType = In.NamedScalarType Definition.string
+    deprecatedDescription = Just
+        "Marks an element of a GraphQL schema as no longer supported."
+    deprecatedLocations =
+        [ TypeSystemDirectiveLocation DirectiveLocation.FieldDefinition
+        , TypeSystemDirectiveLocation DirectiveLocation.ArgumentDefinition
+        , TypeSystemDirectiveLocation DirectiveLocation.InputFieldDefinition
+        , TypeSystemDirectiveLocation DirectiveLocation.EnumValue
+        ]
+
+-- | Traverses the schema and finds all referenced types.
+collectReferencedTypes :: forall m
+    . Out.ObjectType m
+    -> Maybe (Out.ObjectType m)
+    -> Maybe (Out.ObjectType m)
+    -> HashMap Full.Name (Type m)
+    -> HashMap Full.Name (Type m)
+collectReferencedTypes queryRoot mutationRoot subscriptionRoot extraTypes =
+    let queryTypes = traverseObjectType queryRoot extraTypes
+        mutationTypes = maybe queryTypes (`traverseObjectType` queryTypes)
+            mutationRoot
+     in maybe mutationTypes (`traverseObjectType` mutationTypes) subscriptionRoot
+  where
+    collect traverser typeName element foundTypes
+        | HashMap.member typeName foundTypes = foundTypes
+        | otherwise = traverser $ HashMap.insert typeName element foundTypes
+    visitFields (Out.Field _ outputType arguments) foundTypes
+        = traverseOutputType outputType
+        $ foldr visitArguments foundTypes arguments
+    visitArguments (In.Argument _ inputType _) = traverseInputType inputType
+    visitInputFields (In.InputField _ inputType _) = traverseInputType inputType
+    getField (Out.ValueResolver field _) = field
+    getField (Out.EventStreamResolver field _ _) = field
+    traverseInputType (In.InputObjectBaseType objectType) =
+        let In.InputObjectType typeName _ inputFields = objectType
+            element = InputObjectType objectType
+            traverser = flip (foldr visitInputFields) inputFields
+         in collect traverser typeName element
+    traverseInputType (In.ListBaseType listType) =
+        traverseInputType listType
+    traverseInputType (In.ScalarBaseType scalarType) =
+        let Definition.ScalarType typeName _ = scalarType
+         in collect Prelude.id typeName (ScalarType scalarType)
+    traverseInputType (In.EnumBaseType enumType) =
+        let Definition.EnumType typeName _ _ = enumType
+         in collect Prelude.id typeName (EnumType enumType)
+    traverseOutputType (Out.ObjectBaseType objectType) =
+        traverseObjectType objectType
+    traverseOutputType (Out.InterfaceBaseType interfaceType) =
+        traverseInterfaceType interfaceType
+    traverseOutputType (Out.UnionBaseType unionType) =
+        let Out.UnionType typeName _ types' = unionType
+            traverser = flip (foldr traverseObjectType) types'
+         in collect traverser typeName (UnionType unionType)
+    traverseOutputType (Out.ListBaseType listType) =
+        traverseOutputType listType
+    traverseOutputType (Out.ScalarBaseType scalarType) =
+        let Definition.ScalarType typeName _ = scalarType
+         in collect Prelude.id typeName (ScalarType scalarType)
+    traverseOutputType (Out.EnumBaseType enumType) =
+        let Definition.EnumType typeName _ _ = enumType
+         in collect Prelude.id typeName (EnumType enumType)
+    traverseObjectType objectType foundTypes =
+        let Out.ObjectType typeName _ interfaces fields = objectType
+            element = ObjectType objectType
+            traverser = polymorphicTraverser interfaces (getField <$> fields)
+         in collect traverser typeName element foundTypes
+    traverseInterfaceType interfaceType foundTypes =
+        let Out.InterfaceType typeName _ interfaces fields = interfaceType
+            element = InterfaceType interfaceType
+            traverser = polymorphicTraverser interfaces fields
+         in collect traverser typeName element foundTypes
+    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 _ _ _) =
+        HashMap.insertWith (++) typeName [implementation]

src/Language/GraphQL/Validate.hs

@@ -2,80 +2,484 @@
    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 RecordWildCards #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 
 -- | GraphQL validator.
 module Language.GraphQL.Validate
-    ( Error(..)
-    , Path(..)
+    ( Validation.Error(..)
     , document
     , module Language.GraphQL.Validate.Rules
     ) where
 
-import Control.Monad (foldM)
-import Control.Monad.Trans.Reader (Reader, asks, mapReaderT, runReader)
-import Data.Foldable (foldrM)
+import Control.Monad (join)
+import Control.Monad.Trans.Class (MonadTrans(..))
+import Control.Monad.Trans.Reader (runReaderT)
+import Data.Foldable (toList)
+import Data.HashMap.Strict (HashMap)
+import qualified Data.HashMap.Strict as HashMap
 import Data.Sequence (Seq(..), (><), (|>))
 import qualified Data.Sequence as Seq
-import Language.GraphQL.AST.Document
-import Language.GraphQL.Type.Internal
-import Language.GraphQL.Type.Schema (Schema(..))
+import Language.GraphQL.AST.DirectiveLocation (DirectiveLocation(..))
+import qualified Language.GraphQL.AST.DirectiveLocation as DirectiveLocation
+import qualified Language.GraphQL.AST.Document as Full
+import qualified Language.GraphQL.Type.Internal as Type
+import qualified Language.GraphQL.Type.In as In
+import qualified Language.GraphQL.Type.Out as Out
+import Language.GraphQL.Type.Schema (Schema)
+import qualified Language.GraphQL.Type.Schema as Schema
 import Language.GraphQL.Validate.Rules
-import Language.GraphQL.Validate.Validation
+import Language.GraphQL.Validate.Validation (Validation(Validation))
+import qualified Language.GraphQL.Validate.Validation as Validation
 
-type ValidateT m = Reader (Validation m) (Seq Error)
+type ApplySelectionRule m a
+    = HashMap Full.Name (Schema.Type m)
+    -> Validation.Rule m
+    -> Maybe (Out.Type m)
+    -> a
+    -> Seq (Validation.RuleT m)
+
+type ApplyRule m a = Validation.Rule m -> a -> Seq (Validation.RuleT m)
 
 -- | Validates a document and returns a list of found errors. If the returned
 -- list is empty, the document is valid.
-document :: forall m. Schema m -> [Rule m] -> Document -> Seq Error
+document :: forall m
+    . Schema m
+    -> [Validation.Rule m]
+    -> Full.Document
+    -> Seq Validation.Error
 document schema' rules' document' =
-    runReader (foldrM go Seq.empty document') context
+    runReaderT reader context
   where
     context = Validation
-        { ast = document'
-        , schema = schema'
-        , types = collectReferencedTypes schema'
-        , rules = rules'
+        { Validation.ast = document'
+        , Validation.schema = schema'
         }
-    go definition' accumulator = (accumulator ><) <$> definition definition'
+    reader = do
+        rule' <- lift $ Seq.fromList rules'
+        join $ lift $ foldr (definition rule' context) Seq.empty document'
 
-definition :: forall m. Definition -> ValidateT m
-definition = \case
-    definition'@(ExecutableDefinition executableDefinition') -> do
-        applied <- applyRules definition'
-        children <- executableDefinition executableDefinition'
-        pure $ children >< applied
-    definition' -> applyRules definition'
+definition :: Validation.Rule m
+    -> Validation m
+    -> Full.Definition
+    -> Seq (Validation.RuleT m)
+    -> Seq (Validation.RuleT m)
+definition (Validation.DefinitionRule rule) _ definition' accumulator =
+    accumulator |> rule definition'
+definition rule context (Full.ExecutableDefinition definition') accumulator =
+    accumulator >< executableDefinition rule context definition'
+definition rule context (Full.TypeSystemDefinition typeSystemDefinition' _) accumulator =
+    accumulator >< typeSystemDefinition context rule typeSystemDefinition'
+definition rule context (Full.TypeSystemExtension extension _) accumulator =
+    accumulator >< typeSystemExtension context rule extension
+
+typeSystemExtension :: forall m
+    . Validation m
+    -> ApplyRule m Full.TypeSystemExtension
+typeSystemExtension context rule = \case
+    Full.SchemaExtension extension -> schemaExtension context rule extension
+    Full.TypeExtension extension -> typeExtension context rule extension
+
+typeExtension :: forall m. Validation m -> ApplyRule m Full.TypeExtension
+typeExtension context rule = \case
+    Full.ScalarTypeExtension _ directives' ->
+        directives context rule scalarLocation directives'
+    Full.ObjectTypeFieldsDefinitionExtension _ _ directives' fields
+        -> directives context rule objectLocation directives'
+        >< foldMap (fieldDefinition context rule) fields
+    Full.ObjectTypeDirectivesExtension _ _ directives' ->
+        directives context rule objectLocation directives'
+    Full.ObjectTypeImplementsInterfacesExtension _ _ -> mempty
+    Full.InterfaceTypeFieldsDefinitionExtension _ directives' fields
+        -> directives context rule interfaceLocation directives'
+        >< foldMap (fieldDefinition context rule) fields
+    Full.InterfaceTypeDirectivesExtension _ directives' ->
+        directives context rule interfaceLocation directives'
+    Full.UnionTypeUnionMemberTypesExtension _ directives' _ ->
+        directives context rule unionLocation directives'
+    Full.UnionTypeDirectivesExtension _ directives' ->
+        directives context rule unionLocation directives'
+    Full.EnumTypeEnumValuesDefinitionExtension _ directives' values
+        -> directives context rule enumLocation directives'
+        >< foldMap (enumValueDefinition context rule) values
+    Full.EnumTypeDirectivesExtension _ directives' ->
+        directives context rule enumLocation directives'
+    Full.InputObjectTypeInputFieldsDefinitionExtension _ directives' fields
+        -> directives context rule inputObjectLocation directives'
+        >< foldMap forEachInputFieldDefinition fields
+    Full.InputObjectTypeDirectivesExtension _ directives' ->
+        directives context rule inputObjectLocation directives'
   where
-    applyRules definition' =
-        asks rules >>= foldM (ruleFilter definition') Seq.empty
-    ruleFilter definition' accumulator (DefinitionRule rule) =
-        mapReaderT (runRule accumulator) $ rule definition'
-    ruleFilter _ accumulator _ = pure accumulator
+    forEachInputFieldDefinition =
+        inputValueDefinition context rule inputFieldDefinitionLocation
 
-runRule :: Applicative f => Seq Error -> Maybe Error -> f (Seq Error)
-runRule accumulator (Just error') = pure $ accumulator |> error'
-runRule accumulator Nothing = pure accumulator
+schemaExtension :: forall m. Validation m -> ApplyRule m Full.SchemaExtension
+schemaExtension context rule = \case
+    Full.SchemaOperationExtension directives' _ ->
+        directives context rule schemaLocation directives'
+    Full.SchemaDirectivesExtension directives' ->
+        directives context rule schemaLocation directives'
 
-executableDefinition :: forall m. ExecutableDefinition -> ValidateT m
-executableDefinition (DefinitionOperation definition') =
-    operationDefinition definition'
-executableDefinition (DefinitionFragment definition') =
-    fragmentDefinition definition'
+schemaLocation :: DirectiveLocation
+schemaLocation = TypeSystemDirectiveLocation DirectiveLocation.Schema
 
-operationDefinition :: forall m. OperationDefinition -> ValidateT m
-operationDefinition operation =
-    asks rules >>= foldM ruleFilter Seq.empty
+interfaceLocation :: DirectiveLocation
+interfaceLocation = TypeSystemDirectiveLocation DirectiveLocation.Interface
+
+objectLocation :: DirectiveLocation
+objectLocation = TypeSystemDirectiveLocation DirectiveLocation.Object
+
+unionLocation :: DirectiveLocation
+unionLocation = TypeSystemDirectiveLocation DirectiveLocation.Union
+
+enumLocation :: DirectiveLocation
+enumLocation = TypeSystemDirectiveLocation DirectiveLocation.Enum
+
+inputObjectLocation :: DirectiveLocation
+inputObjectLocation = TypeSystemDirectiveLocation DirectiveLocation.InputObject
+
+scalarLocation :: DirectiveLocation
+scalarLocation = TypeSystemDirectiveLocation DirectiveLocation.Scalar
+
+enumValueLocation :: DirectiveLocation
+enumValueLocation = TypeSystemDirectiveLocation DirectiveLocation.EnumValue
+
+fieldDefinitionLocation :: DirectiveLocation
+fieldDefinitionLocation =
+    TypeSystemDirectiveLocation DirectiveLocation.FieldDefinition
+
+inputFieldDefinitionLocation :: DirectiveLocation
+inputFieldDefinitionLocation =
+    TypeSystemDirectiveLocation DirectiveLocation.InputFieldDefinition
+
+argumentDefinitionLocation :: DirectiveLocation
+argumentDefinitionLocation =
+    TypeSystemDirectiveLocation DirectiveLocation.ArgumentDefinition
+
+queryLocation :: DirectiveLocation
+queryLocation = ExecutableDirectiveLocation DirectiveLocation.Query
+
+mutationLocation :: DirectiveLocation
+mutationLocation = ExecutableDirectiveLocation DirectiveLocation.Mutation
+
+subscriptionLocation :: DirectiveLocation
+subscriptionLocation =
+    ExecutableDirectiveLocation DirectiveLocation.Subscription
+
+fieldLocation :: DirectiveLocation
+fieldLocation = ExecutableDirectiveLocation DirectiveLocation.Field
+
+fragmentDefinitionLocation :: DirectiveLocation
+fragmentDefinitionLocation =
+    ExecutableDirectiveLocation DirectiveLocation.FragmentDefinition
+
+fragmentSpreadLocation :: DirectiveLocation
+fragmentSpreadLocation =
+    ExecutableDirectiveLocation DirectiveLocation.FragmentSpread
+
+inlineFragmentLocation :: DirectiveLocation
+inlineFragmentLocation =
+    ExecutableDirectiveLocation DirectiveLocation.InlineFragment
+
+executableDefinition :: forall m
+    . Validation.Rule m
+    -> Validation m
+    -> Full.ExecutableDefinition
+    -> Seq (Validation.RuleT m)
+executableDefinition rule context (Full.DefinitionOperation operation) =
+    operationDefinition rule context operation
+executableDefinition rule context (Full.DefinitionFragment fragment) =
+    fragmentDefinition rule context fragment
+
+typeSystemDefinition :: forall m
+    . Validation m
+    -> ApplyRule m Full.TypeSystemDefinition
+typeSystemDefinition context rule = \case
+    Full.SchemaDefinition directives' _ ->
+        directives context rule schemaLocation directives'
+    Full.TypeDefinition typeDefinition' ->
+        typeDefinition context rule typeDefinition'
+    Full.DirectiveDefinition _ _ arguments' _ ->
+        argumentsDefinition context rule arguments'
+
+typeDefinition :: forall m. Validation m -> ApplyRule m Full.TypeDefinition
+typeDefinition context rule = \case
+    Full.ScalarTypeDefinition _ _ directives' ->
+        directives context rule scalarLocation directives'
+    Full.ObjectTypeDefinition _ _ _ directives' fields
+        -> directives context rule objectLocation directives'
+        >< foldMap (fieldDefinition context rule) fields
+    Full.InterfaceTypeDefinition _ _ directives' fields
+        -> directives context rule interfaceLocation directives'
+        >< foldMap (fieldDefinition context rule) fields
+    Full.UnionTypeDefinition _ _ directives' _ ->
+        directives context rule unionLocation directives'
+    Full.EnumTypeDefinition _ _ directives' values
+        -> directives context rule enumLocation directives'
+        >< foldMap (enumValueDefinition context rule) values
+    Full.InputObjectTypeDefinition _ _ directives' fields
+        -> directives context rule inputObjectLocation directives'
+        <> foldMap forEachInputFieldDefinition fields
   where
-    ruleFilter accumulator (OperationDefinitionRule rule) =
-        mapReaderT (runRule accumulator) $ rule operation
-    ruleFilter accumulator _ = pure accumulator
+    forEachInputFieldDefinition =
+        inputValueDefinition context rule inputFieldDefinitionLocation
 
-fragmentDefinition :: forall m. FragmentDefinition -> ValidateT m
-fragmentDefinition fragment =
-    asks rules >>= foldM ruleFilter Seq.empty
+enumValueDefinition :: forall m
+    . Validation m
+    -> ApplyRule m Full.EnumValueDefinition
+enumValueDefinition context rule (Full.EnumValueDefinition _ _ directives') =
+    directives context rule enumValueLocation directives'
+
+fieldDefinition :: forall m. Validation m -> ApplyRule m Full.FieldDefinition
+fieldDefinition context rule (Full.FieldDefinition _ _ arguments' _ directives')
+    = directives context rule fieldDefinitionLocation directives'
+    >< argumentsDefinition context rule arguments'
+
+argumentsDefinition :: forall m
+    . Validation m
+    -> ApplyRule m Full.ArgumentsDefinition
+argumentsDefinition context rule (Full.ArgumentsDefinition definitions) =
+    foldMap forEachArgument definitions
   where
-    ruleFilter accumulator (FragmentDefinitionRule rule) =
-        mapReaderT (runRule accumulator) $ rule fragment
-    ruleFilter accumulator _ = pure accumulator
+    forEachArgument =
+        inputValueDefinition context rule argumentDefinitionLocation
+
+inputValueDefinition :: forall m
+    . Validation m
+    -> Validation.Rule m
+    -> DirectiveLocation
+    -> Full.InputValueDefinition
+    -> Seq (Validation.RuleT m)
+inputValueDefinition context rule directiveLocation definition' =
+    let Full.InputValueDefinition _ _ _ _ directives' = definition'
+     in directives context rule directiveLocation directives'
+
+operationDefinition :: forall m
+    . Validation.Rule m
+    -> Validation m
+    -> Full.OperationDefinition
+    -> Seq (Validation.RuleT m)
+operationDefinition rule context operation
+    | Validation.OperationDefinitionRule operationRule <- rule =
+        pure $ operationRule operation
+    | Validation.VariablesRule variablesRule <- rule
+    , Full.OperationDefinition _ _ variables _ _ _ <- operation =
+        foldMap (variableDefinition context rule) variables |> variablesRule variables
+    | Full.SelectionSet selections _ <- operation =
+        selectionSet context types' rule queryRoot selections
+    | Full.OperationDefinition Full.Query _ _ directives' selections _  <- operation
+        = selectionSet context types' rule queryRoot selections
+        >< directives context rule queryLocation directives'
+    | Full.OperationDefinition Full.Mutation _ _ directives' selections _  <- operation =
+        let root = Out.NamedObjectType <$> Schema.mutation schema'
+         in selectionSet context types' rule root selections
+        >< directives context rule mutationLocation directives'
+    | Full.OperationDefinition Full.Subscription _ _ directives' selections _  <- operation =
+        let root = Out.NamedObjectType <$> Schema.subscription schema'
+         in selectionSet context types' rule root selections
+        >< directives context rule subscriptionLocation directives'
+  where
+    schema' = Validation.schema context
+    queryRoot = Just $ Out.NamedObjectType $ Schema.query schema'
+    types' = Schema.types schema'
+        
+typeToOut :: forall m. Schema.Type m -> Maybe (Out.Type m)
+typeToOut (Schema.ObjectType objectType) =
+    Just $ Out.NamedObjectType objectType
+typeToOut (Schema.InterfaceType interfaceType) =
+    Just $ Out.NamedInterfaceType interfaceType
+typeToOut (Schema.UnionType unionType) = Just $ Out.NamedUnionType unionType
+typeToOut (Schema.EnumType enumType) = Just $ Out.NamedEnumType enumType
+typeToOut (Schema.ScalarType scalarType) = Just $ Out.NamedScalarType scalarType
+typeToOut _ = Nothing
+
+variableDefinition :: forall m
+    . Validation m
+    -> ApplyRule m Full.VariableDefinition
+variableDefinition context rule (Full.VariableDefinition _ typeName value' _)
+    | Just defaultValue' <- value'
+    , types <- Schema.types $ Validation.schema context
+    , variableType <- Type.lookupInputType typeName types =
+        constValue rule variableType defaultValue'
+variableDefinition _ _ _ = mempty
+
+constValue :: forall m
+    . Validation.Rule m
+    -> Maybe In.Type
+    -> Full.Node Full.ConstValue
+    -> Seq (Validation.RuleT m)
+constValue (Validation.ValueRule _ rule) valueType = go valueType
+  where
+    go inputObjectType value'@(Full.Node (Full.ConstObject fields) _)
+        = foldMap (forEach inputObjectType) (Seq.fromList fields)
+        |> rule inputObjectType value'
+    go anotherValue value' = pure $ rule anotherValue value'
+    forEach inputObjectType Full.ObjectField{value = value', ..} =
+        go (valueTypeByName name inputObjectType) value'
+constValue _ _ = const mempty
+
+inputFieldType :: In.InputField -> In.Type
+inputFieldType (In.InputField _ inputFieldType' _) = inputFieldType'
+
+valueTypeByName :: Full.Name -> Maybe In.Type -> Maybe In.Type
+valueTypeByName fieldName (Just( In.InputObjectBaseType inputObjectType)) =
+    let In.InputObjectType _ _ fieldTypes = inputObjectType
+     in inputFieldType <$> HashMap.lookup fieldName fieldTypes
+valueTypeByName _ _ = Nothing
+
+fragmentDefinition :: forall m
+    . Validation.Rule m
+    -> Validation m
+    -> Full.FragmentDefinition
+    -> Seq (Validation.RuleT m)
+fragmentDefinition (Validation.FragmentDefinitionRule rule) _ definition' =
+    pure $ rule definition'
+fragmentDefinition rule context definition'
+    | Full.FragmentDefinition _ typeCondition directives' selections _ <- definition'
+    , Validation.FragmentRule definitionRule _ <- rule
+        = applyToChildren typeCondition directives' selections
+        |> definitionRule definition'
+    | Full.FragmentDefinition _ typeCondition directives' selections _ <- definition'
+        = applyToChildren typeCondition directives' selections
+  where
+    types' = Schema.types $ Validation.schema context
+    applyToChildren typeCondition directives' selections
+        = selectionSet context types' rule (lookupType' typeCondition) selections
+        >< directives context rule fragmentDefinitionLocation directives'
+    lookupType' = flip lookupType types'
+
+lookupType :: forall m
+    . Full.TypeCondition
+    -> HashMap Full.Name (Schema.Type m)
+    -> Maybe (Out.Type m)
+lookupType typeCondition types' = HashMap.lookup typeCondition types'
+    >>= typeToOut
+
+selectionSet :: Traversable t
+    => forall m
+    . Validation m
+    -> ApplySelectionRule m (t Full.Selection)
+selectionSet context types' rule = foldMap . selection context types' rule
+
+selection :: forall m. Validation m -> ApplySelectionRule m Full.Selection
+selection context types' rule objectType selection'
+    | Validation.SelectionRule selectionRule <- rule =
+        applyToChildren |> selectionRule objectType selection'
+    | otherwise = applyToChildren
+  where
+    applyToChildren =
+        case selection' of
+            Full.FieldSelection field' ->
+                field context types' rule objectType field'
+            Full.InlineFragmentSelection inlineFragment' ->
+                inlineFragment context types' rule objectType inlineFragment'
+            Full.FragmentSpreadSelection fragmentSpread' ->
+                fragmentSpread context rule fragmentSpread'
+
+field :: forall m. Validation m -> ApplySelectionRule m Full.Field
+field context types' rule objectType field' = go field'
+  where
+    go (Full.Field _ fieldName _ _ _ _)
+        | Validation.FieldRule fieldRule <- rule =
+            applyToChildren fieldName |> fieldRule objectType field'
+        | Validation.ArgumentsRule argumentsRule _  <- rule =
+            applyToChildren fieldName |> argumentsRule objectType field'
+        | otherwise = applyToChildren fieldName
+    typeFieldType (Out.Field _ type' _) = type'
+    typeFieldArguments (Out.Field _ _ argumentTypes) = argumentTypes
+    applyToChildren fieldName =
+        let Full.Field _ _ arguments' directives' selections _ = field'
+            typeField = objectType >>= Type.lookupTypeField fieldName
+            argumentTypes = maybe mempty typeFieldArguments typeField
+         in selectionSet context types' rule (typeFieldType <$> typeField) selections
+            >< directives context rule fieldLocation directives'
+            >< arguments rule argumentTypes arguments'
+
+arguments :: forall m
+    . Validation.Rule m
+    -> In.Arguments
+    -> [Full.Argument]
+    -> Seq (Validation.RuleT m)
+arguments rule argumentTypes = foldMap forEach . Seq.fromList
+  where
+    forEach argument'@(Full.Argument argumentName _ _) = 
+       let argumentType = HashMap.lookup argumentName argumentTypes
+        in argument rule argumentType argument'
+
+argument :: forall m
+    . Validation.Rule m
+    -> Maybe In.Argument
+    -> Full.Argument
+    -> Seq (Validation.RuleT m)
+argument rule argumentType (Full.Argument _ value' _) =
+    value rule (valueType <$> argumentType) value'
+  where
+    valueType (In.Argument _ valueType' _) = valueType'
+
+value :: forall m
+    . Validation.Rule m
+    -> Maybe In.Type
+    -> Full.Node Full.Value
+    -> Seq (Validation.RuleT m)
+value (Validation.ValueRule rule _) valueType = go valueType
+  where
+    go inputObjectType value'@(Full.Node (Full.Object fields) _)
+        = foldMap (forEach inputObjectType) (Seq.fromList fields)
+        |> rule inputObjectType value'
+    go anotherValue value' = pure $ rule anotherValue value'
+    forEach inputObjectType Full.ObjectField{value = value', ..} =
+        go (valueTypeByName name inputObjectType) value'
+value _ _ = const mempty
+
+inlineFragment :: forall m
+    . Validation m
+    -> ApplySelectionRule m Full.InlineFragment
+inlineFragment context types' rule objectType inlineFragment' =
+    go inlineFragment'
+  where
+    go (Full.InlineFragment optionalType directives' selections _)
+        | Validation.FragmentRule _ fragmentRule <- rule
+            = applyToChildren (refineTarget optionalType) directives' selections
+            |> fragmentRule inlineFragment'
+        | otherwise = applyToChildren (refineTarget optionalType) directives' selections
+    refineTarget (Just typeCondition) = lookupType typeCondition types'
+    refineTarget Nothing = objectType
+    applyToChildren objectType' directives' selections
+        = selectionSet context types' rule objectType' selections
+        >< directives context rule inlineFragmentLocation directives'
+
+fragmentSpread :: forall m. Validation m -> ApplyRule m Full.FragmentSpread
+fragmentSpread context rule fragmentSpread'@(Full.FragmentSpread _ directives' _)
+    | Validation.FragmentSpreadRule fragmentRule <- rule =
+        applyToChildren |> fragmentRule fragmentSpread'
+    | otherwise = applyToChildren
+  where
+    applyToChildren = directives context rule fragmentSpreadLocation directives'
+
+directives :: Traversable t
+    => forall m
+    . Validation m
+    -> Validation.Rule m
+    -> DirectiveLocation
+    -> t Full.Directive
+    -> Seq (Validation.RuleT m)
+directives context rule directiveLocation directives'
+    | Validation.DirectivesRule directivesRule <- rule =
+        applyToChildren |> directivesRule directiveLocation directiveList
+    | otherwise = applyToChildren
+  where
+    directiveList = toList directives'
+    applyToChildren = foldMap (directive context rule) directiveList
+
+directive :: forall m. Validation m -> ApplyRule m Full.Directive
+directive _ (Validation.ArgumentsRule _ argumentsRule) directive' =
+    pure $ argumentsRule directive'
+directive context rule (Full.Directive directiveName arguments' _) =
+    let argumentTypes = maybe HashMap.empty directiveArguments
+            $ HashMap.lookup directiveName
+            $ Schema.directives
+            $ Validation.schema context
+     in arguments rule argumentTypes arguments'
+  where
+    directiveArguments (Schema.Directive _ _ argumentTypes) = argumentTypes

src/Language/GraphQL/Validate/Validation.hs

@@ -5,41 +5,29 @@
 -- | Definitions used by the validation rules and the validator itself.
 module Language.GraphQL.Validate.Validation
     ( Error(..)
-    , Path(..)
     , Rule(..)
     , RuleT
     , Validation(..)
     ) where
 
-import Control.Monad.Trans.Reader (ReaderT(..))
-import Data.HashMap.Strict (HashMap)
-import Data.Text (Text)
+import Control.Monad.Trans.Reader (ReaderT)
+import Data.Sequence (Seq)
+import Language.GraphQL.AST.DirectiveLocation (DirectiveLocation(..))
 import Language.GraphQL.AST.Document
+import qualified Language.GraphQL.Type.In as In
+import qualified Language.GraphQL.Type.Out as Out
 import Language.GraphQL.Type.Schema (Schema)
-import qualified Language.GraphQL.Type.Schema as Schema
-
--- | 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
--- whether a null result is intentional or caused by a runtime error.
-data Path
-    = Segment Text -- ^ Field name.
-    | Index Int -- ^ List index if a field returned a list.
-    deriving (Eq, Show)
 
 -- | Validation error.
 data Error = Error
     { message :: String
     , locations :: [Location]
-    , path :: [Path]
     } deriving (Eq, Show)
 
 -- | Validation rule context.
 data Validation m = Validation
     { ast :: Document
     , schema :: Schema m
-    , types :: HashMap Name (Schema.Type m)
-    , rules :: [Rule m]
     }
 
 -- | 'Rule' assigns a function to each AST node that can be validated. If the
@@ -49,6 +37,14 @@ data Rule m
     = DefinitionRule (Definition -> RuleT m)
     | OperationDefinitionRule (OperationDefinition -> RuleT m)
     | FragmentDefinitionRule (FragmentDefinition -> RuleT m)
+    | SelectionRule (Maybe (Out.Type m) -> Selection -> RuleT m)
+    | FragmentRule (FragmentDefinition -> RuleT m) (InlineFragment -> RuleT m)
+    | FragmentSpreadRule (FragmentSpread -> RuleT m)
+    | FieldRule (Maybe (Out.Type m) -> Field -> RuleT m)
+    | ArgumentsRule (Maybe (Out.Type m) -> Field -> RuleT m) (Directive -> RuleT m)
+    | DirectivesRule (DirectiveLocation -> [Directive] -> RuleT m)
+    | VariablesRule ([VariableDefinition] -> RuleT m)
+    | ValueRule (Maybe In.Type -> Node Value -> RuleT m) (Maybe In.Type -> Node ConstValue -> RuleT m)
 
 -- | Monad transformer used by the rules.
-type RuleT m = ReaderT (Validation m) Maybe Error
+type RuleT m = ReaderT (Validation m) Seq Error

src/Test/Hspec/GraphQL.hs

@@ -1,41 +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 #-}
-
--- | Test helpers.
-module Test.Hspec.GraphQL
-    ( shouldResolve
-    , shouldResolveTo
-    ) where
-
-import Control.Monad.Catch (MonadCatch)
-import qualified Data.Aeson as Aeson
-import qualified Data.HashMap.Strict as HashMap
-import Data.Text (Text)
-import Language.GraphQL.Error
-import Test.Hspec.Expectations (Expectation, expectationFailure, shouldBe, shouldNotSatisfy)
-
--- | Asserts that a query resolves to some value.
-shouldResolveTo :: MonadCatch m
-    => Either (ResponseEventStream m Aeson.Value) Aeson.Object
-    -> Aeson.Object
-    -> Expectation
-shouldResolveTo (Right actual) expected = actual `shouldBe` expected
-shouldResolveTo _ _ = expectationFailure
-    "the query is expected to resolve to a value, but it resolved to an event stream"
-
--- | Asserts that the response doesn't contain any errors.
-shouldResolve :: MonadCatch m
-    => (Text -> IO (Either (ResponseEventStream m Aeson.Value) Aeson.Object))
-    -> Text
-    -> Expectation
-shouldResolve executor query = do
-    actual <- executor query
-    case actual of
-        Right response ->
-            response `shouldNotSatisfy` HashMap.member "errors"
-        _ -> expectationFailure
-            "the query is expected to resolve to a value, but it resolved to an event stream"

stack.yaml

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

tests/Language/GraphQL/AST/Arbitrary.hs

@@ -0,0 +1,102 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Language.GraphQL.AST.Arbitrary where
+
+import qualified Language.GraphQL.AST.Document as Doc
+import Test.QuickCheck.Arbitrary (Arbitrary (arbitrary))
+import Test.QuickCheck (oneof, elements, listOf, resize, NonEmptyList (..))
+import Test.QuickCheck.Gen (Gen (..))
+import Data.Text (Text, pack)
+import Data.Functor ((<&>))
+
+newtype AnyPrintableChar = AnyPrintableChar { getAnyPrintableChar :: Char } deriving (Eq, Show)
+
+alpha :: String
+alpha = ['a'..'z'] <> ['A'..'Z']
+
+num :: String
+num = ['0'..'9']
+
+instance Arbitrary AnyPrintableChar where
+    arbitrary = AnyPrintableChar <$> elements chars
+        where
+           chars = alpha <> num <> ['_'] 
+
+newtype AnyPrintableText = AnyPrintableText { getAnyPrintableText :: Text } deriving (Eq, Show)
+
+instance Arbitrary AnyPrintableText where
+    arbitrary = do
+        nonEmptyStr <- getNonEmpty <$> (arbitrary :: Gen (NonEmptyList AnyPrintableChar))
+        pure $ AnyPrintableText (pack $ map getAnyPrintableChar nonEmptyStr)
+
+-- https://spec.graphql.org/June2018/#Name
+newtype AnyName = AnyName { getAnyName :: Text } deriving (Eq, Show)
+
+instance Arbitrary AnyName where
+    arbitrary = do
+        firstChar <- elements $ alpha <> ['_']
+        rest <- (arbitrary :: Gen [AnyPrintableChar])
+        pure $ AnyName (pack $ firstChar : map getAnyPrintableChar rest)
+
+newtype AnyLocation = AnyLocation { getAnyLocation :: Doc.Location } deriving (Eq, Show)
+
+instance Arbitrary AnyLocation where
+    arbitrary = AnyLocation <$> (Doc.Location <$> arbitrary <*> arbitrary)
+
+newtype AnyNode a = AnyNode { getAnyNode :: Doc.Node a } deriving (Eq, Show)
+
+instance Arbitrary a => Arbitrary (AnyNode a) where
+    arbitrary = do
+        (AnyLocation location') <- arbitrary
+        node' <- flip Doc.Node location' <$> arbitrary
+        pure $ AnyNode node'
+
+newtype AnyObjectField a = AnyObjectField { getAnyObjectField :: Doc.ObjectField a } deriving (Eq, Show)
+
+instance Arbitrary a => Arbitrary (AnyObjectField a) where
+    arbitrary = do
+        name' <- getAnyName <$> arbitrary
+        value' <- getAnyNode <$> arbitrary
+        location' <- getAnyLocation <$> arbitrary
+        pure $ AnyObjectField $ Doc.ObjectField name' value' location'
+
+newtype AnyValue = AnyValue { getAnyValue :: Doc.Value }
+    deriving (Eq, Show)
+
+instance Arbitrary AnyValue
+  where
+    arbitrary =
+        let variableGen :: Gen Doc.Value
+            variableGen = Doc.Variable . getAnyName <$> arbitrary
+            listGen :: Gen [Doc.Node Doc.Value]
+            listGen = (resize 5 . listOf) nodeGen
+            nodeGen :: Gen (Doc.Node Doc.Value)
+            nodeGen = fmap getAnyNode arbitrary <&> fmap getAnyValue
+            objectGen :: Gen [Doc.ObjectField Doc.Value]
+            objectGen = resize 1
+                $ fmap getNonEmpty arbitrary
+                <&> map (fmap getAnyValue . getAnyObjectField)
+         in AnyValue <$> oneof
+            [ variableGen
+            , Doc.Int <$> arbitrary
+            , Doc.Float <$> arbitrary
+            , Doc.String . getAnyPrintableText <$> arbitrary
+            , Doc.Boolean <$> arbitrary
+            , MkGen $ \_ _ -> Doc.Null
+            , Doc.Enum . getAnyName <$> arbitrary
+            , Doc.List <$> listGen
+            , Doc.Object <$> objectGen
+            ]
+
+newtype AnyArgument a = AnyArgument { getAnyArgument :: Doc.Argument }
+    deriving (Eq, Show)
+
+instance Arbitrary a => Arbitrary (AnyArgument a) where
+    arbitrary = do
+        name' <- getAnyName <$> arbitrary
+        (AnyValue value') <- arbitrary
+        (AnyLocation location') <- arbitrary
+        pure $ AnyArgument $ Doc.Argument name' (Doc.Node value' location') location'
+
+printArgument :: AnyArgument AnyValue -> Text
+printArgument (AnyArgument (Doc.Argument name' (Doc.Node value' _) _)) = name' <> ": " <> (pack . show) value'

tests/Language/GraphQL/AST/DocumentSpec.hs

@@ -0,0 +1,26 @@
+{-# 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
+
+    describe "Description" $
+        it "keeps content when merging with no description" $
+            let expected = Description $ Just "Left description"
+                actual = expected <> Description Nothing
+             in actual `shouldBe` expected

tests/Language/GraphQL/AST/EncoderSpec.hs

@@ -4,67 +4,77 @@ module Language.GraphQL.AST.EncoderSpec
     ( spec
     ) where
 
-import Language.GraphQL.AST
+import Data.List.NonEmpty (NonEmpty(..))
+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 Data.Text.Lazy (cons, toStrict, unpack)
+import qualified Data.Text.Lazy as Text.Lazy
 
 spec :: Spec
 spec = do
     describe "value" $ do
         context "null value" $ do
-            let testNull formatter = value formatter Null `shouldBe` "null"
+            let testNull formatter = value formatter Full.Null `shouldBe` "null"
             it "minified" $ testNull minified
             it "pretty" $ testNull pretty
 
         context "minified" $ do
             it "escapes \\" $
-                value minified (String "\\") `shouldBe` "\"\\\\\""
+                value minified (Full.String "\\") `shouldBe` "\"\\\\\""
             it "escapes double quotes" $
-                value minified (String "\"") `shouldBe` "\"\\\"\""
+                value minified (Full.String "\"") `shouldBe` "\"\\\"\""
             it "escapes \\f" $
-                value minified (String "\f") `shouldBe` "\"\\f\""
+                value minified (Full.String "\f") `shouldBe` "\"\\f\""
             it "escapes \\n" $
-                value minified (String "\n") `shouldBe` "\"\\n\""
+                value minified (Full.String "\n") `shouldBe` "\"\\n\""
             it "escapes \\r" $
-                value minified (String "\r") `shouldBe` "\"\\r\""
+                value minified (Full.String "\r") `shouldBe` "\"\\r\""
             it "escapes \\t" $
-                value minified (String "\t") `shouldBe` "\"\\t\""
+                value minified (Full.String "\t") `shouldBe` "\"\\t\""
             it "escapes backspace" $
-                value minified (String "a\bc") `shouldBe` "\"a\\bc\""
+                value minified (Full.String "a\bc") `shouldBe` "\"a\\bc\""
             context "escapes Unicode for chars less than 0010" $ do
-                it "Null" $ value minified (String "\x0000") `shouldBe` "\"\\u0000\""
-                it "bell" $ value minified (String "\x0007") `shouldBe` "\"\\u0007\""
+                it "Null" $ value minified (Full.String "\x0000") `shouldBe` "\"\\u0000\""
+                it "bell" $ value minified (Full.String "\x0007") `shouldBe` "\"\\u0007\""
             context "escapes Unicode for char less than 0020" $ do
-                it "DLE" $ value minified (String "\x0010") `shouldBe` "\"\\u0010\""
-                it "EM" $ value minified (String "\x0019") `shouldBe` "\"\\u0019\""
+                it "DLE" $ value minified (Full.String "\x0010") `shouldBe` "\"\\u0010\""
+                it "EM" $ value minified (Full.String "\x0019") `shouldBe` "\"\\u0019\""
             context "encodes without escape" $ do
-                it "space" $ value minified (String "\x0020") `shouldBe` "\" \""
-                it "~" $ value minified (String "\x007E") `shouldBe` "\"~\""
+                it "space" $ value minified (Full.String "\x0020") `shouldBe` "\" \""
+                it "~" $ value minified (Full.String "\x007E") `shouldBe` "\"~\""
 
         context "pretty" $ do
             it "uses strings for short string values" $
-                value pretty (String "Short text") `shouldBe` "\"Short text\""
+                value pretty (Full.String "Short text") `shouldBe` "\"Short text\""
             it "uses block strings for text with new lines, with newline symbol" $
-                value pretty (String "Line 1\nLine 2")
-                    `shouldBe` [r|"""
-  Line 1
-  Line 2
-"""|]
+                let expected = [gql|
+                  """
+                    Line 1
+                    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 (String "Line 1\rLine 2")
-                    `shouldBe` [r|"""
-  Line 1
-  Line 2
-"""|]
+                let expected = [gql|
+                  """
+                    Line 1
+                    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 (String "Line 1\r\nLine 2")
-                    `shouldBe` [r|"""
-  Line 1
-  Line 2
-"""|]
+                let expected = [gql|
+                  """
+                    Line 1
+                    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,60 +86,184 @@ spec = do
 
                 forAll genNotAllowedSymbol $ \x -> do
                     let
-                      rawValue = "Short \n" <> cons x "text"
-                      encoded = value pretty (String $ toStrict rawValue)
-                    shouldStartWith (unpack encoded) "\""
-                    shouldEndWith (unpack encoded) "\""
-                    shouldNotContain (unpack encoded) "\"\"\""
+                      rawValue = "Short \n" <> Text.Lazy.cons x "text"
+                      encoded = value pretty
+                          $ Full.String $ Text.Lazy.toStrict rawValue
+                    shouldStartWith (Text.Lazy.unpack encoded) "\""
+                    shouldEndWith (Text.Lazy.unpack encoded) "\""
+                    shouldNotContain (Text.Lazy.unpack encoded) "\"\"\""
 
-            it "Hello world" $ value pretty (String "Hello,\n  World!\n\nYours,\n  GraphQL.")
-              `shouldBe` [r|"""
-  Hello,
-    World!
+            it "Hello world" $
+                let actual = value pretty
+                        $ Full.String "Hello,\n  World!\n\nYours,\n  GraphQL."
+                    expected = [gql|
+                      """
+                        Hello,
+                          World!
 
-  Yours,
-    GraphQL.
-"""|]
+                        Yours,
+                          GraphQL.
+                      """
+                    |]
+                  in actual `shouldBe` expected
 
-            it "has only newlines" $ value pretty (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 (String "a\n\n") `shouldBe` [r|"""
-  a
+                let actual = value pretty $ Full.String "a\n\n"
+                    expected = [gql|
+                      """
+                        a
 
 
-"""|]
+                      """|]
+                 in actual `shouldBe` expected
             it "has newlines and one symbol at the end" $
-              value pretty (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 (String "\na\n") `shouldBe` [r|"""
+                let actual = value pretty $ Full.String "\na\n"
+                    expected = [gql|
+                      """
 
-  a
+                        a
 
-"""|]
-            it "skip trailing whitespaces" $ value pretty (String "  Short\ntext    ")
-              `shouldBe` [r|"""
-  Short
-  text
-"""|]
+                      """
+                    |]
+                 in actual `shouldBe` expected
+            it "skip trailing whitespaces" $
+                let actual = value pretty $ Full.String "  Short\ntext    "
+                    expected = [gql|
+                      """
+                        Short
+                        text
+                      """
+                    |]
+                 in actual `shouldBe` expected
 
     describe "definition" $
         it "indents block strings in arguments" $
-            let arguments = [Argument "message" (String "line1\nline2")]
-                field = Field Nothing "field" arguments [] []
-                operation = DefinitionOperation
-                    $ SelectionSet (pure field)
-                    $ Location 0 0
-             in definition pretty operation `shouldBe` [r|{
-  field(message: """
-    line1
-    line2
-  """)
-}
-|]
+            let location = Full.Location 0 0
+                argumentValue = Full.Node (Full.String "line1\nline2") location
+                arguments = [Full.Argument "message" argumentValue location]
+                field = Full.Field Nothing "field" arguments [] [] location
+                fieldSelection = pure $ Full.FieldSelection field
+                operation = Full.DefinitionOperation
+                    $ Full.SelectionSet fieldSelection location
+                expected = Text.Lazy.snoc [gql|
+                  {
+                    field(message: """
+                      line1
+                      line2
+                    """)
+                  }
+                |] '\n'
+                actual = definition pretty operation
+             in actual `shouldBe` expected
+
+    describe "operationType" $
+        it "produces lowercase mutation operation type" $
+            let actual = operationType pretty Full.Mutation
+             in actual `shouldBe` "mutation"
+
+    describe "typeSystemDefinition" $ do
+        it "produces a schema with an indented operation type definition" $
+            let queryType = Full.OperationTypeDefinition Full.Query "QueryRootType"
+                mutationType = Full.OperationTypeDefinition Full.Mutation "MutationType"
+                operations = queryType :| pure mutationType
+                definition' = Full.SchemaDefinition [] operations
+                expected = Text.Lazy.snoc [gql|
+                  schema {
+                    query: QueryRootType
+                    mutation: MutationType
+                  }
+                |] '\n'
+                actual = typeSystemDefinition pretty definition'
+             in actual `shouldBe` expected
+
+        it "encodes a scalar type definition" $
+            let uuidType = Full.ScalarTypeDefinition mempty "UUID" mempty
+                definition' = Full.TypeDefinition uuidType
+                expected = "scalar UUID"
+                actual = typeSystemDefinition pretty definition'
+             in actual `shouldBe` expected
+
+        it "encodes an interface definition" $
+            let someType = Full.TypeNamed "String"
+                argument = Full.InputValueDefinition mempty "arg" someType Nothing mempty
+                arguments = Full.ArgumentsDefinition [argument]
+                definition' = Full.TypeDefinition
+                    $ Full.InterfaceTypeDefinition mempty "UUID" mempty
+                    $ pure
+                    $ Full.FieldDefinition mempty "value" arguments someType mempty
+                expected = [gql|
+                  interface UUID {
+                    value(arg: String): String
+                  }
+                |]
+                actual = typeSystemDefinition pretty definition'
+             in actual `shouldBe` expected
+
+        it "encodes an union definition" $
+            let definition' = Full.TypeDefinition
+                    $ Full.UnionTypeDefinition mempty "SearchResult" mempty
+                    $ Full.UnionMemberTypes ["Photo", "Person"]
+                expected = [gql|
+                  union SearchResult =
+                    | Photo
+                    | Person
+                |]
+                actual = typeSystemDefinition pretty definition'
+             in actual `shouldBe` expected
+
+        it "encodes an enum definition" $
+            let values =
+                    [ Full.EnumValueDefinition mempty "NORTH" mempty
+                    , Full.EnumValueDefinition mempty "EAST" mempty
+                    , Full.EnumValueDefinition mempty "SOUTH" mempty
+                    , Full.EnumValueDefinition mempty "WEST" mempty
+                    ]
+                definition' = Full.TypeDefinition
+                    $ Full.EnumTypeDefinition mempty "Direction" mempty values
+                expected = [gql|
+                  enum Direction {
+                    NORTH
+                    EAST
+                    SOUTH
+                    WEST
+                  }
+                |]
+                actual = typeSystemDefinition pretty definition'
+             in actual `shouldBe` expected
+
+        it "encodes an input type" $
+            let intType = Full.TypeNonNull $ Full.NonNullTypeNamed "Int"
+                stringType = Full.TypeNamed "String"
+                fields =
+                    [ Full.InputValueDefinition mempty "a" stringType Nothing mempty
+                    , Full.InputValueDefinition mempty "b" intType Nothing mempty
+                    ]
+                definition' = Full.TypeDefinition
+                    $ Full.InputObjectTypeDefinition mempty "ExampleInputObject" mempty fields
+                expected = [gql|
+                  input ExampleInputObject {
+                    a: String
+                    b: Int!
+                  }
+                |]
+                actual = typeSystemDefinition pretty definition'
+             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 "" [r|" white space "|] `shouldParse` " white space "
-            parse string "" [r|"quote \""|] `shouldParse` [r|quote "|]
-            parse string "" [r|"escaped \n"|] `shouldParse` "escaped \n"
-            parse string "" [r|"slashes \\ \/"|] `shouldParse` [r|slashes \ /|]
-            parse string "" [r|"unicode \u1234\u5678\u90AB\uCDEF"|]
+            parse string "" [gql|"simple"|] `shouldParse` "simple"
+            parse string "" [gql|" white space "|] `shouldParse` " white space "
+            parse string "" [gql|"quote \""|] `shouldParse` [gql|quote "|]
+            parse string "" [gql|"escaped \n"|] `shouldParse` "escaped \n"
+            parse string "" [gql|"slashes \\ \/"|] `shouldParse` [gql|slashes \ /|]
+            parse string "" [gql|"unicode \u1234\u5678\u90AB\uCDEF"|]
                 `shouldParse` "unicode ሴ噸邫췯"
 
         it "lexes block string" $ do
-            parse blockString "" [r|"""simple"""|] `shouldParse` "simple"
-            parse blockString "" [r|""" white space """|]
+            parse blockString "" [gql|"""simple"""|] `shouldParse` "simple"
+            parse blockString "" [gql|""" white space """|]
                 `shouldParse` " white space "
-            parse blockString "" [r|"""contains " quote"""|]
-                `shouldParse` [r|contains " quote|]
-            parse blockString "" [r|"""contains \""" triplequote"""|]
-                `shouldParse` [r|contains """ triplequote|]
+            parse blockString "" [gql|"""contains " quote"""|]
+                `shouldParse` [gql|contains " quote|]
+            parse blockString "" [gql|"""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"""|]
-                `shouldParse` [r|unescaped \n\r\b\t\f\u1234|]
-            parse blockString "" [r|"""slashes \\ \/"""|]
-                `shouldParse` [r|slashes \\ \/|]
-            parse blockString "" [r|"""
+            parse blockString "" [gql|"""unescaped \n\r\b\t\f\u1234"""|]
+                `shouldParse` [gql|unescaped \n\r\b\t\f\u1234|]
+            parse blockString "" [gql|"""slashes \\ \/"""|]
+                `shouldParse` [gql|slashes \\ \/|]
+            parse blockString "" [gql|"""
 
                 spans
                   multiple
@@ -75,16 +75,16 @@ spec = describe "Lexer" $ do
             parse dollar "" "$" `shouldParse` "$"
             runBetween parens `shouldSucceedOn` "()"
             parse spread "" "..." `shouldParse` "..."
-            parse colon "" ":" `shouldParse` ":"
+            parse colon "" `shouldSucceedOn` ":"
             parse equals "" "=" `shouldParse` "="
-            parse at "" "@" `shouldParse` "@"
+            parse at "" `shouldSucceedOn` "@"
             runBetween brackets `shouldSucceedOn` "[]"
             runBetween braces `shouldSucceedOn` "{}"
             parse pipe "" "|" `shouldParse` "|"
 
     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

@@ -5,97 +5,120 @@ module Language.GraphQL.AST.ParserSpec
     ) where
 
 import Data.List.NonEmpty (NonEmpty(..))
+import Data.Text (Text)
+import qualified Data.Text as Text
 import Language.GraphQL.AST.Document
+import qualified Language.GraphQL.AST.DirectiveLocation as DirLoc
 import Language.GraphQL.AST.Parser
-import Test.Hspec (Spec, describe, it)
+import Language.GraphQL.TH
+import Test.Hspec (Spec, describe, it, context)
 import Test.Hspec.Megaparsec (shouldParse, shouldFailOn, shouldSucceedOn)
 import Text.Megaparsec (parse)
-import Text.RawString.QQ (r)
+import Test.QuickCheck (property, NonEmptyList (..), mapSize)
+import Language.GraphQL.AST.Arbitrary
 
 spec :: Spec
 spec = describe "Parser" $ do
     it "accepts BOM header" $
         parse document "" `shouldSucceedOn` "\xfeff{foo}"
 
-    it "accepts block strings as argument" $
-        parse document "" `shouldSucceedOn` [r|{
-              hello(text: """Argument""")
-            }|]
+    context "Arguments" $ do
+       it "accepts block strings as argument" $
+           parse document "" `shouldSucceedOn` [gql|{
+                 hello(text: """Argument""")
+               }|]
 
-    it "accepts strings as argument" $
-        parse document "" `shouldSucceedOn` [r|{
-              hello(text: "Argument")
-            }|]
+       it "accepts strings as argument" $
+           parse document "" `shouldSucceedOn` [gql|{
+                 hello(text: "Argument")
+               }|]
 
-    it "accepts two required arguments" $
-        parse document "" `shouldSucceedOn` [r|
-            mutation auth($username: String!, $password: String!){
-              test
-            }|]
+       it "accepts int as argument1" $
+           parse document "" `shouldSucceedOn` [gql|{
+                 user(id: 4)
+               }|]
 
-    it "accepts two string arguments" $
-        parse document "" `shouldSucceedOn` [r|
-            mutation auth{
-              test(username: "username", password: "password")
-            }|]
+       it "accepts boolean as argument" $
+           parse document "" `shouldSucceedOn` [gql|{
+                 hello(flag: true) { field1 }
+               }|]
 
-    it "accepts two block string arguments" $
-        parse document "" `shouldSucceedOn` [r|
-            mutation auth{
-              test(username: """username""", password: """password""")
-            }|]
+       it "accepts float as argument" $
+           parse document "" `shouldSucceedOn` [gql|{
+                 body(height: 172.5) { height }
+               }|]
+
+       it "accepts empty list as argument" $
+           parse document "" `shouldSucceedOn` [gql|{
+                 query(list: []) { field1 }
+               }|]
+
+       it "accepts two required arguments" $
+           parse document "" `shouldSucceedOn` [gql|
+               mutation auth($username: String!, $password: String!){
+                 test
+               }|]
+
+       it "accepts two string arguments" $
+           parse document "" `shouldSucceedOn` [gql|
+               mutation auth{
+                 test(username: "username", password: "password")
+               }|]
+
+       it "accepts two block string arguments" $
+           parse document "" `shouldSucceedOn` [gql|
+               mutation auth{
+                 test(username: """username""", password: """password""")
+               }|]
+ 
+       it "accepts any arguments" $ mapSize (const 10) $ property $ \xs ->
+            let
+                query' :: Text
+                arguments = map printArgument $ getNonEmpty (xs :: NonEmptyList (AnyArgument AnyValue))
+                query' = "query(" <> Text.intercalate ", " arguments <> ")" in
+            parse document "" `shouldSucceedOn` ("{ " <> query' <> " }")
 
     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|
-            enum Direction {
-              NORTH
-              EAST
-              SOUTH
-              WEST
-            }
-        |]
-
-    it "parses minimal enum type definition" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             enum Direction {
               NORTH
               EAST
@@ -105,7 +128,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,46 +136,103 @@ 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" []
+        let newDirective = Directive "newDirective" [] $ Location 1 15
             schemaExtension = SchemaExtension
                 $ SchemaOperationExtension [newDirective]
                 $ 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 "rejects empty selection set" $
+       parse document "" `shouldFailOn` [gql|
+            query {
+              innerField {}
+            }
+        |]
+
     it "parses documents beginning with a comment" $
-        parse document "" `shouldSucceedOn` [r|
+        parse document "" `shouldSucceedOn` [gql|
             """
             Query
             """
@@ -162,7 +242,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

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

tests/Language/GraphQL/Execute/CoerceSpec.hs

@@ -7,12 +7,8 @@ module Language.GraphQL.Execute.CoerceSpec
     ( spec
     ) where
 
-import Data.Aeson as Aeson ((.=))
-import qualified Data.Aeson as Aeson
-import qualified Data.Aeson.Types as Aeson
 import qualified Data.HashMap.Strict as HashMap
 import Data.Maybe (isNothing)
-import Data.Scientific (scientific)
 import qualified Language.GraphQL.Execute.Coerce as Coerce
 import Language.GraphQL.Type
 import qualified Language.GraphQL.Type.In as In
@@ -27,81 +23,11 @@ direction = EnumType "Direction" Nothing  $ HashMap.fromList
     , ("WEST", EnumValue Nothing)
     ]
 
-singletonInputObject :: In.Type
-singletonInputObject = In.NamedInputObjectType type'
-  where
-    type' = In.InputObjectType "ObjectName" Nothing inputFields
-    inputFields = HashMap.singleton "field" field
-    field = In.InputField Nothing (In.NamedScalarType string) Nothing
-
 namedIdType :: In.Type
 namedIdType = In.NamedScalarType id
 
 spec :: Spec
-spec = do
-    describe "VariableValue Aeson" $ do
-        it "coerces strings" $
-            let expected = Just (String "asdf")
-                actual = Coerce.coerceVariableValue
-                    (In.NamedScalarType string) (Aeson.String "asdf")
-             in actual `shouldBe` expected
-        it "coerces non-null strings" $
-            let expected = Just (String "asdf")
-                actual = Coerce.coerceVariableValue
-                    (In.NonNullScalarType string) (Aeson.String "asdf")
-             in actual `shouldBe` expected
-        it "coerces booleans" $
-            let expected = Just (Boolean True)
-                actual = Coerce.coerceVariableValue
-                    (In.NamedScalarType boolean) (Aeson.Bool True)
-             in actual `shouldBe` expected
-        it "coerces zero to an integer" $
-            let expected = Just (Int 0)
-                actual = Coerce.coerceVariableValue
-                    (In.NamedScalarType int) (Aeson.Number 0)
-             in actual `shouldBe` expected
-        it "rejects fractional if an integer is expected" $
-            let actual = Coerce.coerceVariableValue
-                    (In.NamedScalarType int) (Aeson.Number $ scientific 14 (-1))
-             in actual `shouldSatisfy` isNothing
-        it "coerces float numbers" $
-            let expected = Just (Float 1.4)
-                actual = Coerce.coerceVariableValue
-                    (In.NamedScalarType float) (Aeson.Number $ scientific 14 (-1))
-             in actual `shouldBe` expected
-        it "coerces IDs" $
-            let expected = Just (String "1234")
-                json = Aeson.String "1234"
-                actual = Coerce.coerceVariableValue namedIdType json
-             in actual `shouldBe` expected
-        it "coerces input objects" $
-            let actual = Coerce.coerceVariableValue singletonInputObject
-                    $ Aeson.object ["field" .= ("asdf" :: Aeson.Value)]
-                expected = Just $ Object $ HashMap.singleton "field" "asdf"
-             in actual `shouldBe` expected
-        it "skips the field if it is missing in the variables" $
-            let actual = Coerce.coerceVariableValue
-                    singletonInputObject Aeson.emptyObject
-                expected = Just $ Object HashMap.empty
-             in actual `shouldBe` expected
-        it "fails if input object value contains extra fields" $
-            let actual = Coerce.coerceVariableValue singletonInputObject
-                    $ Aeson.object variableFields
-                variableFields =
-                    [ "field" .= ("asdf" :: Aeson.Value)
-                    , "extra" .= ("qwer" :: Aeson.Value)
-                    ]
-             in actual `shouldSatisfy` isNothing
-        it "preserves null" $
-            let actual = Coerce.coerceVariableValue namedIdType Aeson.Null
-             in actual `shouldBe` Just Null
-        it "preserves list order" $
-            let list = Aeson.toJSONList ["asdf" :: Aeson.Value, "qwer"]
-                listType = (In.ListType $ In.NamedScalarType string)
-                actual = Coerce.coerceVariableValue listType list
-                expected = Just $ List [String "asdf", String "qwer"]
-             in actual `shouldBe` expected
-
+spec =
     describe "coerceInputLiteral" $ do
         it "coerces enums" $
             let expected = Just (Enum "NORTH")

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

@@ -2,67 +2,210 @@
    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 LambdaCase #-}
+{-# LANGUAGE NamedFieldPuns #-}
+{-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes #-}
+
 module Language.GraphQL.ExecuteSpec
     ( spec
     ) where
 
-import Control.Exception (SomeException)
-import Data.Aeson ((.=))
-import qualified Data.Aeson as Aeson
+import Control.Exception (Exception(..))
+import Control.Monad.Catch (throwM)
 import Data.Conduit
 import Data.HashMap.Strict (HashMap)
 import qualified Data.HashMap.Strict as HashMap
-import Language.GraphQL.AST (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.Type as Type
-import Language.GraphQL.Type.Out as Out
+import Language.GraphQL.Execute (execute)
+import Language.GraphQL.TH
+import qualified Language.GraphQL.Type.Schema as Schema
+import qualified Language.GraphQL.Type as Type
+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.Megaparsec (parse, errorBundlePretty)
+import Schemas.HeroSchema (heroSchema)
+import Data.Maybe (fromJust)
+import qualified Data.Sequence as Seq
+import Data.Text (Text)
+import qualified Data.Text as Text
+import Test.Hspec.Expectations
+    ( Expectation
+    , expectationFailure
+    )
+import Data.Either (fromRight)
 
-schema :: Schema (Either SomeException)
-schema = Schema
-    { query = queryType
-    , mutation = Nothing
-    , subscription = Just subscriptionType
-    }
+data PhilosopherException = PhilosopherException
+    deriving Show
 
-queryType :: Out.ObjectType (Either SomeException)
+instance Exception PhilosopherException where
+    toException = toException. ResolverException
+    fromException e = do
+        ResolverException resolverException <- fromException e
+        cast resolverException
+
+philosopherSchema :: Schema IO
+philosopherSchema =
+    schemaWithTypes Nothing queryType Nothing subscriptionRoot extraTypes mempty
+  where
+    subscriptionRoot = Just subscriptionType
+    extraTypes =
+        [ Schema.ObjectType bookType
+        , Schema.ObjectType bookCollectionType
+        ]
+
+queryType :: Out.ObjectType IO
 queryType = Out.ObjectType "Query" Nothing []
-    $ HashMap.singleton "philosopher" 
-    $ ValueResolver philosopherField
-    $ pure $ Type.Object mempty
+    $ HashMap.fromList
+    [ ("philosopher", ValueResolver philosopherField philosopherResolver)
+    , ("throwing", ValueResolver throwingField throwingResolver)
+    , ("count", ValueResolver countField countResolver)
+    , ("sequence", ValueResolver sequenceField sequenceResolver)
+    , ("withInputObject", ValueResolver withInputObjectField withInputObjectResolver)
+    ]
   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
+    throwingField =
+        let fieldType = Out.ListType $ Out.NonNullScalarType string
+         in Out.Field Nothing fieldType HashMap.empty
+    throwingResolver :: Resolve IO
+    throwingResolver = throwM PhilosopherException
+    countField =
+        let fieldType = Out.NonNullScalarType int
+         in Out.Field Nothing fieldType HashMap.empty
+    countResolver = pure ""
+    sequenceField =
+        let fieldType = Out.ListType $ Out.NonNullScalarType int
+         in Out.Field Nothing fieldType HashMap.empty
+    sequenceResolver = pure intSequence
+    withInputObjectResolver = pure $ Type.Int 0
+    withInputObjectField =
+        Out.Field Nothing (Out.NonNullScalarType int) $ HashMap.fromList
+            [("values", In.Argument Nothing withInputObjectArgumentType Nothing)]
+    withInputObjectArgumentType = In.NonNullListType
+        $ In.NonNullInputObjectType inputObjectType
 
-philosopherType :: Out.ObjectType (Either SomeException)
+inputObjectType :: In.InputObjectType
+inputObjectType = In.InputObjectType "InputObject" Nothing $
+    HashMap.singleton "name" $
+        In.InputField Nothing (In.NonNullScalarType int) Nothing
+
+intSequence :: Value
+intSequence = Type.List [Type.Int 1, Type.Int 2, Type.Int 3]
+
+musicType :: Out.ObjectType IO
+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 IO
+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 IO
+interestType = Out.UnionType "Interest" Nothing [musicType, poetryType]
+
+philosopherType :: Out.ObjectType IO
 philosopherType = Out.ObjectType "Philosopher" Nothing []
     $ HashMap.fromList resolvers
   where
     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
 
-subscriptionType :: Out.ObjectType (Either SomeException)
+workType :: Out.InterfaceType IO
+workType = Out.InterfaceType "Work" Nothing []
+    $ HashMap.fromList fields
+  where
+    fields = [("title", titleField)]
+    titleField = Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
+
+bookType :: Out.ObjectType IO
+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 IO
+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 IO
 subscriptionType = Out.ObjectType "Subscription" Nothing []
     $ HashMap.singleton "newQuote"
-    $ EventStreamResolver quoteField (pure $ Type.Object mempty)
-    $ pure $ yield $ Type.Object mempty
+    $ EventStreamResolver quoteField (pure $ Object mempty)
+    $ pure $ yield $ Object mempty
   where
     quoteField =
         Out.Field Nothing (Out.NonNullObjectType quoteType) HashMap.empty
 
-quoteType :: Out.ObjectType (Either SomeException)
+quoteType :: Out.ObjectType IO
 quoteType = Out.ObjectType "Quote" Nothing []
     $ HashMap.singleton "quote"
     $ ValueResolver quoteField
@@ -71,43 +214,260 @@ quoteType = Out.ObjectType "Quote" Nothing []
     quoteField =
         Out.Field Nothing (Out.NonNullScalarType string) HashMap.empty
 
+schoolType :: Type.EnumType
+schoolType = EnumType "School" Nothing $ HashMap.fromList
+    [ ("NOMINALISM", EnumValue Nothing)
+    , ("REALISM", EnumValue Nothing)
+    , ("IDEALISM", EnumValue Nothing)
+    ]
+
+type EitherStreamOrValue = Either
+    (ResponseEventStream IO Type.Value)
+    (Response Type.Value)
+
+-- Asserts that a query resolves to a value.
+shouldResolveTo :: Text.Text -> Response Type.Value -> Expectation
+shouldResolveTo querySource expected =
+    case parse document "" querySource of
+        (Right parsedDocument) ->
+            execute philosopherSchema Nothing (mempty :: HashMap Name Type.Value) parsedDocument >>= go
+        (Left errorBundle) -> expectationFailure $ errorBundlePretty errorBundle
+  where
+    go = \case
+        Right result -> shouldBe result expected
+        Left _ -> expectationFailure
+            "the query is expected to resolve to a value, but it resolved to an event stream"
+
+-- Asserts that the executor produces an error that starts with a string.
+shouldContainError :: Either (ResponseEventStream IO Type.Value) (Response Type.Value)
+    -> Text
+    -> Expectation
+shouldContainError streamOrValue expected =
+    case streamOrValue of
+        Right response -> respond response
+        Left _ -> expectationFailure
+            "the query is expected to resolve to a value, but it resolved to an event stream"
+  where
+    startsWith :: Text.Text -> Text.Text -> Bool
+    startsWith xs ys = Text.take (Text.length ys) xs == ys
+    respond :: Response Type.Value -> Expectation
+    respond Response{ errors }
+        | any ((`startsWith` expected) . message) errors = pure ()
+        | otherwise = expectationFailure
+            "the query is expected to execute with errors, but the response doesn't contain any errors"
+
+parseAndExecute :: Schema IO
+    -> Maybe Text
+    -> HashMap Name Type.Value
+    -> Text
+    -> IO (Either (ResponseEventStream IO Type.Value) (Response Type.Value))
+parseAndExecute schema' operation variables
+    = either (pure . parseError) (execute schema' operation variables)
+    . parse document ""
+
 spec :: Spec
 spec =
     describe "execute" $ do
+        it "rejects recursive fragments" $
+            let sourceQuery = [gql|
+              {
+                ...cyclicFragment
+              }
+
+              fragment cyclicFragment on Query {
+                ...cyclicFragment
+              }
+            |]
+                expected = Response (Object mempty) mempty
+             in sourceQuery `shouldResolveTo` expected
+
         context "Query" $ do
             it "skips unknown fields" $
-                let data'' = Aeson.object
-                        [ "philosopher" .= Aeson.object
-                            [ "firstName" .= ("Friedrich" :: String)
-                            ]
-                        ]
+                let data'' = Object
+                        $ HashMap.singleton "philosopher"
+                        $ Object
+                        $ HashMap.singleton "firstName"
+                        $ String "Friedrich"
                     expected = Response data'' mempty
-                    execute' = execute schema Nothing (mempty :: HashMap Name Aeson.Value)
-                    Right (Right actual) = either (pure . parseError) execute'
-                        $ parse document "" "{ philosopher { firstName surname } }"
-                in actual `shouldBe` expected
+                    sourceQuery = "{ philosopher { firstName surname } }"
+                in sourceQuery `shouldResolveTo` expected
             it "merges selections" $
-                let data'' = Aeson.object
-                        [ "philosopher" .= Aeson.object
-                            [ "firstName" .= ("Friedrich" :: String)
-                            , "lastName" .= ("Nietzsche" :: String)
+                let data'' = Object
+                        $ HashMap.singleton "philosopher"
+                        $ Object
+                        $ HashMap.fromList
+                            [ ("firstName", String "Friedrich")
+                            , ("lastName", String "Nietzsche")
                             ]
-                        ]
                     expected = Response data'' mempty
-                    execute' = execute schema Nothing (mempty :: HashMap Name Aeson.Value)
-                    Right (Right actual) = either (pure . parseError) execute'
-                        $ parse document "" "{ philosopher { firstName } philosopher { lastName } }"
-                in actual `shouldBe` expected
+                    sourceQuery = "{ philosopher { firstName } philosopher { lastName } }"
+                in sourceQuery `shouldResolveTo` expected
+
+            it "errors on invalid output enum values" $
+                let data'' = Object $ HashMap.singleton "philosopher" 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
+                    sourceQuery = "{ philosopher { school } }"
+                 in sourceQuery `shouldResolveTo` expected
+
+            it "gives location information for non-null unions" $
+                let data'' = Object $ HashMap.singleton "philosopher" 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
+                    sourceQuery = "{ philosopher { interest } }"
+                 in sourceQuery `shouldResolveTo` expected
+
+            it "gives location information for invalid interfaces" $
+                let data'' = Object $ HashMap.singleton "philosopher" 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
+                    sourceQuery = "{ philosopher { majorWork { title } } }"
+                 in sourceQuery `shouldResolveTo` expected
+
+            it "gives location information for failed result coercion" $
+                let data'' = Object $ HashMap.singleton "philosopher" Null
+                    executionErrors = pure $ Error
+                        { message = "Unable to coerce result to Int!."
+                        , locations = [Location 1 26]
+                        , path = [Segment "philosopher", Segment "century"]
+                        }
+                    expected = Response data'' executionErrors
+                    sourceQuery = "{ philosopher(id: \"1\") { century } }"
+                in sourceQuery `shouldResolveTo` expected
+
+            it "gives location information for failed result coercion" $
+                let data'' = Object $ HashMap.singleton "throwing" Null
+                    executionErrors = pure $ Error
+                        { message = "PhilosopherException"
+                        , locations = [Location 1 3]
+                        , path = [Segment "throwing"]
+                        }
+                    expected = Response data'' executionErrors
+                    sourceQuery = "{ throwing }"
+                in sourceQuery `shouldResolveTo` 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 Null executionErrors
+                    sourceQuery = "{ count }"
+                in sourceQuery `shouldResolveTo` expected
+
+            it "detects nullability errors" $
+                let data'' = Object $ HashMap.singleton "philosopher" 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
+                    sourceQuery = "{ philosopher(id: \"1\") { firstLanguage } }"
+                in sourceQuery `shouldResolveTo` expected
+
+            it "returns list elements in the original order" $
+                let data'' = Object $ HashMap.singleton "sequence" intSequence
+                    expected = Response data'' mempty
+                    sourceQuery = "{ sequence }"
+                in sourceQuery `shouldResolveTo` expected
+
+            context "Arguments" $ do
+                it "gives location information for invalid scalar arguments" $
+                    let data'' = Object $ HashMap.singleton "philosopher" 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
+                        sourceQuery = "{ philosopher(id: true) { lastName } }"
+                    in sourceQuery `shouldResolveTo` expected
+
+                it "puts an object in a list if needed" $
+                    let data'' = Object $ HashMap.singleton "withInputObject" $ Type.Int 0
+                        expected = Response data'' mempty
+                        sourceQuery = "{ withInputObject(values: { name: 0 }) }"
+                    in sourceQuery `shouldResolveTo` expected
+
+            context "queryError" $ do
+                let namedQuery name = "query " <> name <> " { philosopher(id: \"1\") { interest } }"
+                    twoQueries = namedQuery "A" <> " " <> namedQuery "B"
+
+                it "throws operation name is required error" $ do
+                    let expectedErrorMessage = "Operation name is required"
+                    actual <- parseAndExecute philosopherSchema Nothing mempty twoQueries
+                    actual `shouldContainError` expectedErrorMessage
+
+                it "throws operation not found error" $ do
+                    let expectedErrorMessage = "Operation \"C\" is not found"
+                    actual <- parseAndExecute philosopherSchema (Just "C") mempty twoQueries
+                    actual `shouldContainError` expectedErrorMessage
+
+                it "throws variable coercion error" $ do
+                    let data'' = Null
+                        executionErrors = pure $ Error
+                            { message = "Failed to coerce the variable $id: String."
+                            , locations =[Location 1 7]
+                            , path = []
+                            }
+                        expected = Response data'' executionErrors
+                        executeWithVars = execute philosopherSchema Nothing (HashMap.singleton "id" (Type.Int 1))
+                    Right actual <- either (pure . parseError) executeWithVars
+                        $ parse document "" "query($id: String) { philosopher(id: \"1\") { firstLanguage } }"
+                    actual `shouldBe` expected
+
+                it "throws variable unkown input type error" $
+                    let data'' = Null
+                        executionErrors = pure $ Error
+                            { message = "Variable $id has unknown type Cat."
+                            , locations =[Location 1 7]
+                            , path = []
+                            }
+                        expected = Response data'' executionErrors
+                        sourceQuery = "query($id: Cat) { philosopher(id: \"1\") { firstLanguage } }"
+                     in sourceQuery `shouldResolveTo` expected
+
+            context "Error path" $ do
+                let executeHero :: Document -> IO EitherStreamOrValue
+                    executeHero = execute heroSchema Nothing (HashMap.empty :: HashMap Name Type.Value)
+
+                it "at the beggining of the list" $ do
+                    Right actual <- either (pure . parseError) executeHero
+                        $ parse document "" "{ hero(id: \"1\") { friends { name } } }"
+                    let Response _ errors' = actual
+                        Error _ _ path' = fromJust $ Seq.lookup 0 errors'
+                        expected = [Segment "hero", Segment "friends", Index 0, Segment "name"]
+                     in path' `shouldBe` expected
+
         context "Subscription" $
-            it "subscribes" $
-                let data'' = Aeson.object
-                        [ "newQuote" .= Aeson.object
-                            [ "quote" .= ("Naturam expelles furca, tamen usque recurret." :: String)
-                            ]
-                        ]
+            it "subscribes" $ do
+                let data'' = Object
+                        $ HashMap.singleton "newQuote"
+                        $ Object
+                        $ HashMap.singleton "quote"
+                        $ String "Naturam expelles furca, tamen usque recurret."
                     expected = Response data'' mempty
-                    execute' = execute schema Nothing (mempty :: HashMap Name Aeson.Value)
-                    Right (Left stream) = either (pure . parseError) execute'
-                        $ parse document "" "subscription { newQuote { quote } }"
-                    Right (Just actual) = runConduit $ stream .| await
-                in actual `shouldBe` expected
+                Left stream <- execute philosopherSchema Nothing (mempty :: HashMap Name Type.Value)
+                    $ fromRight (error "Parse error")
+                    $ parse document "" "subscription { newQuote { quote } }"
+                Just actual <- runConduit $ stream .| await
+                actual `shouldBe` expected

tests/Language/GraphQL/ValidateSpec.hs

@@ -1,283 +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.Sequence (Seq(..))
-import qualified Data.Sequence as Seq
-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)
-import Text.Megaparsec (parse)
-import Text.RawString.QQ (r)
-
-schema :: Schema IO
-schema = Schema
-    { query = queryType
-    , mutation = Nothing
-    , subscription = Nothing
-    } 
-
-queryType :: ObjectType IO
-queryType = ObjectType "Query" Nothing []
-    $ HashMap.singleton "dog" dogResolver
-  where
-    dogField = Field Nothing (Out.NamedObjectType dogType) mempty
-    dogResolver = ValueResolver dogField $ 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
-
-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
-{-
-alienType :: ObjectType IO
-alienType = ObjectType "Alien" Nothing [sentientType] $ HashMap.fromList
-    [ ("name", nameResolver)
-    , ("homePlanet", homePlanetResolver)
-    ]
-  where
-    nameField = Field Nothing (Out.NonNullScalarType string) mempty
-    nameResolver = ValueResolver nameField $ pure "Name"
-    homePlanetField =
-        Field Nothing (Out.NamedScalarType string) mempty
-    homePlanetResolver = ValueResolver homePlanetField $ pure "Home planet"
--}
-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 []
-{-
-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)
-    , ("doesKnowCommand", doesKnowCommandResolver)
-    , ("meowVolume", meowVolumeResolver)
-    ]
-  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"
-    doesKnowCommandField = Field Nothing (Out.NonNullScalarType boolean)
-        $ HashMap.singleton "catCommand"
-        $ In.Argument Nothing (In.NonNullEnumType catCommandType) Nothing
-    doesKnowCommandResolver = ValueResolver doesKnowCommandField
-        $ pure $ Boolean True
-    meowVolumeField = Field Nothing (Out.NamedScalarType int) mempty
-    meowVolumeResolver = ValueResolver meowVolumeField $ pure $ Int 2
-
-catOrDogType :: UnionType IO
-catOrDogType = UnionType "CatOrDog" Nothing [catType, dogType]
-
-dogOrHumanType :: UnionType IO
-dogOrHumanType = UnionType "DogOrHuman" Nothing [dogType, humanType]
-
-humanOrAlienType :: UnionType IO
-humanOrAlienType = UnionType "HumanOrAlien" Nothing [humanType, alienType]
--}
-validate :: Text -> Seq Error
-validate queryString =
-    case parse AST.document "" queryString of
-        Left _ -> Seq.empty
-        Right ast -> document schema 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]
-                    , path = []
-                    }
-             in validate queryString `shouldBe` Seq.singleton 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]
-                    , path = []
-                    }
-             in validate queryString `shouldBe` Seq.singleton 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]
-                    , path = []
-                    }
-             in validate queryString `shouldBe` Seq.singleton 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]
-                    , path = []
-                    }
-             in validate queryString `shouldBe` Seq.singleton 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]
-                    , path = []
-                    }
-             in validate queryString `shouldBe` Seq.singleton 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]
-                    , path = []
-                    }
-             in validate queryString `shouldBe` Seq.singleton expected

tests/Schemas/HeroSchema.hs

@@ -0,0 +1,70 @@
+{- 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 Schemas.HeroSchema (heroSchema) where
+
+import Control.Exception (Exception(..))
+import Control.Monad.Catch (throwM)
+import Language.GraphQL.Error (ResolverException (..))
+import qualified Language.GraphQL.Type.In as In
+import qualified Language.GraphQL.Type as Type
+import Language.GraphQL.Type.Schema (schemaWithTypes)
+import qualified Data.HashMap.Strict as HashMap
+import Data.Typeable (cast)
+import qualified Language.GraphQL.Type.Out as Out
+
+data HeroException = HeroException
+    deriving Show
+
+instance Exception HeroException where
+    toException = toException. ResolverException
+    fromException e = do
+        ResolverException resolverException <- fromException e
+        cast resolverException
+
+heroSchema :: Type.Schema IO
+heroSchema =
+    schemaWithTypes Nothing queryType Nothing Nothing [] mempty
+
+type ObjectType = Out.ObjectType IO
+
+queryType :: ObjectType
+queryType = Out.ObjectType "Query" Nothing []
+    $ HashMap.fromList
+        [ ("hero", Out.ValueResolver heroField heroResolver)
+        ]
+  where
+    heroField = Out.Field Nothing (Out.NamedObjectType heroType)
+        $ HashMap.singleton "id"
+        $ In.Argument Nothing (In.NamedScalarType Type.id) Nothing
+    heroResolver = pure $ Type.Object mempty
+
+stringField :: Out.Field IO
+stringField = Out.Field Nothing (Out.NonNullScalarType Type.string) HashMap.empty
+
+heroType :: ObjectType
+heroType = Out.ObjectType "Hero" Nothing [] $ HashMap.fromList resolvers
+  where
+    resolvers =
+        [ ("id", Out.ValueResolver stringField (pure $ Type.String "4111"))
+        , ("name", Out.ValueResolver stringField (pure $ Type.String "R2D2"))
+        , ("friends", Out.ValueResolver friendsField (pure $ Type.List [luke]))
+        ]
+    friendsField = Out.Field Nothing (Out.ListType $ Out.NonNullObjectType lukeType) HashMap.empty
+    -- This list values are ignored because of current realisation (types and resolvers are the same entity)
+    -- The values from lukeType will be used
+    luke = Type.Object $ HashMap.fromList
+        [ ("id", "dfdfdf")
+        , ("name", "dfdfdff")
+        ]
+
+lukeType :: ObjectType
+lukeType = Out.ObjectType "Luke" Nothing [] $ HashMap.fromList resolvers
+  where
+    resolvers =
+        [ ("id", Out.ValueResolver stringField (pure $ Type.String "1000"))
+        , ("name", Out.ValueResolver stringField (throwM HeroException))
+        ]

tests/Test/DirectiveSpec.hs

@@ -1,93 +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 Test.DirectiveSpec
-    ( spec
-    ) where
-
-import Data.Aeson (object, (.=))
-import qualified Data.Aeson as Aeson
-import qualified Data.HashMap.Strict as HashMap
-import Language.GraphQL
-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
-    { query = queryType, mutation = Nothing, subscription = Nothing }
-  where
-    queryType = Out.ObjectType "Query" Nothing []
-        $ HashMap.singleton "experimentalField"
-        $ Out.ValueResolver (Out.Field Nothing (Out.NamedScalarType int) mempty)
-        $ pure $ Int 5
-
-emptyObject :: Aeson.Object
-emptyObject = HashMap.singleton "data" $ object []
-
-spec :: Spec
-spec =
-    describe "Directive executor" $ do
-        it "should be able to @skip fields" $ do
-            let sourceQuery = [r|
-              {
-                experimentalField @skip(if: true)
-              }
-            |]
-
-            actual <- graphql experimentalResolver sourceQuery
-            actual `shouldResolveTo` emptyObject
-
-        it "should not skip fields if @skip is false" $ do
-            let sourceQuery = [r|
-              {
-                experimentalField @skip(if: false)
-              }
-            |]
-                expected = HashMap.singleton "data"
-                    $ object
-                        [ "experimentalField" .= (5 :: Int)
-                        ]
-            actual <- graphql experimentalResolver sourceQuery
-            actual `shouldResolveTo` expected
-
-        it "should skip fields if @include is false" $ do
-            let sourceQuery = [r|
-              {
-                experimentalField @include(if: false)
-              }
-            |]
-
-            actual <- graphql experimentalResolver sourceQuery
-            actual `shouldResolveTo` emptyObject
-
-        it "should be able to @skip a fragment spread" $ do
-            let sourceQuery = [r|
-              {
-                ...experimentalFragment @skip(if: true)
-              }
-
-              fragment experimentalFragment on ExperimentalType {
-                experimentalField
-              }
-            |]
-
-            actual <- graphql experimentalResolver sourceQuery
-            actual `shouldResolveTo` emptyObject
-
-        it "should be able to @skip an inline fragment" $ do
-            let sourceQuery = [r|
-              {
-                ... on ExperimentalType @skip(if: true) {
-                  experimentalField
-                }
-              }
-            |]
-
-            actual <- graphql experimentalResolver sourceQuery
-            actual `shouldResolveTo` emptyObject

tests/Test/FragmentSpec.hs

@@ -1,223 +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 Test.FragmentSpec
-    ( spec
-    ) where
-
-import Data.Aeson ((.=))
-import qualified Data.Aeson as Aeson
-import qualified Data.HashMap.Strict as HashMap
-import Data.Text (Text)
-import Language.GraphQL
-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)
-
-size :: (Text, Value)
-size = ("size", String "L")
-
-circumference :: (Text, Value)
-circumference = ("circumference", Int 60)
-
-garment :: Text -> (Text, Value)
-garment typeName =
-    ("garment",  Object $ HashMap.fromList
-        [ if typeName == "Hat" then circumference else size
-        , ("__typename", String typeName)
-        ]
-    )
-
-inlineQuery :: Text
-inlineQuery = [r|{
-  garment {
-    ... on Hat {
-      circumference
-    }
-    ... on Shirt {
-      size
-    }
-  }
-}|]
-
-shirtType :: Out.ObjectType IO
-shirtType = Out.ObjectType "Shirt" Nothing []
-    $ HashMap.fromList
-        [ ("size", sizeFieldType)
-        , ("circumference", circumferenceFieldType)
-        ]
-
-hatType :: Out.ObjectType IO
-hatType = Out.ObjectType "Hat" Nothing []
-    $ HashMap.fromList
-        [ ("size", sizeFieldType)
-        , ("circumference", circumferenceFieldType)
-        ]
-
-circumferenceFieldType :: Out.Resolver IO
-circumferenceFieldType
-    = Out.ValueResolver (Out.Field Nothing (Out.NamedScalarType int) mempty)
-    $ pure $ snd circumference
-
-sizeFieldType :: Out.Resolver IO
-sizeFieldType
-    = Out.ValueResolver (Out.Field Nothing (Out.NamedScalarType string) mempty)
-    $ pure $ snd size
-
-toSchema :: Text -> (Text, Value) -> Schema IO
-toSchema t (_, resolve) = Schema
-    { query = queryType, mutation = Nothing, subscription = Nothing }
-  where
-    unionMember = if t == "Hat" then hatType else shirtType
-    typeNameField = Out.Field Nothing (Out.NamedScalarType string) mempty
-    garmentField = Out.Field Nothing (Out.NamedObjectType unionMember) mempty
-    queryType =
-        case t of
-            "circumference" -> hatType
-            "size" -> shirtType
-            _ -> Out.ObjectType "Query" Nothing []
-                $ HashMap.fromList
-                    [ ("garment", ValueResolver garmentField (pure resolve))
-                    , ("__typename", ValueResolver typeNameField (pure $ String "Shirt"))
-                    ]
-
-spec :: Spec
-spec = do
-    describe "Inline fragment executor" $ do
-        it "chooses the first selection if the type matches" $ do
-            actual <- graphql (toSchema "Hat" $ garment "Hat") inlineQuery
-            let expected = HashMap.singleton "data"
-                    $ Aeson.object
-                        [ "garment" .= Aeson.object
-                            [ "circumference" .= (60 :: Int)
-                            ]
-                        ]
-             in actual `shouldResolveTo` expected
-
-        it "chooses the last selection if the type matches" $ do
-            actual <- graphql (toSchema "Shirt" $ garment "Shirt") inlineQuery
-            let expected = HashMap.singleton "data"
-                    $ Aeson.object
-                        [ "garment" .= Aeson.object
-                            [ "size" .= ("L" :: Text)
-                            ]
-                        ]
-             in actual `shouldResolveTo` expected
-
-        it "embeds inline fragments without type" $ do
-            let sourceQuery = [r|{
-              garment {
-                circumference
-                ... {
-                  size
-                }
-              }
-            }|]
-                resolvers = ("garment", Object $ HashMap.fromList [circumference,  size])
-
-            actual <- graphql (toSchema "garment" resolvers) sourceQuery
-            let expected = HashMap.singleton "data"
-                    $ Aeson.object
-                        [ "garment" .= Aeson.object
-                            [ "circumference" .= (60 :: Int)
-                            , "size" .= ("L" :: Text)
-                            ]
-                        ]
-             in actual `shouldResolveTo` expected
-
-        it "evaluates fragments on Query" $ do
-            let sourceQuery = [r|{
-              ... {
-                size
-              }
-            }|]
-             in graphql (toSchema "size" size) `shouldResolve` sourceQuery
-
-    describe "Fragment spread executor" $ do
-        it "evaluates fragment spreads" $ do
-            let sourceQuery = [r|
-              {
-                ...circumferenceFragment
-              }
-
-              fragment circumferenceFragment on Hat {
-                circumference
-              }
-            |]
-
-            actual <- graphql (toSchema "circumference" circumference) sourceQuery
-            let expected = HashMap.singleton "data"
-                    $ Aeson.object
-                        [ "circumference" .= (60 :: Int)
-                        ]
-             in actual `shouldResolveTo` expected
-
-        it "evaluates nested fragments" $ do
-            let sourceQuery = [r|
-              {
-                garment {
-                  ...circumferenceFragment
-                }
-              }
-
-              fragment circumferenceFragment on Hat {
-                ...hatFragment
-              }
-
-              fragment hatFragment on Hat {
-                circumference
-              }
-            |]
-
-            actual <- graphql (toSchema "Hat" $ garment "Hat") sourceQuery
-            let expected = HashMap.singleton "data"
-                    $ Aeson.object
-                        [ "garment" .= Aeson.object
-                            [ "circumference" .= (60 :: Int)
-                            ]
-                        ]
-             in actual `shouldResolveTo` expected
-
-        it "rejects recursive fragments" $ do
-            let expected = HashMap.singleton "data" $ Aeson.object []
-                sourceQuery = [r|
-              {
-                ...circumferenceFragment
-              }
-
-              fragment circumferenceFragment on Hat {
-                ...circumferenceFragment
-              }
-            |]
-
-            actual <- graphql (toSchema "circumference" circumference) sourceQuery
-            actual `shouldResolveTo` expected
-
-        it "considers type condition" $ do
-            let sourceQuery = [r|
-              {
-                garment {
-                  ...circumferenceFragment
-                  ...sizeFragment
-                }
-              }
-              fragment circumferenceFragment on Hat {
-                circumference
-              }
-              fragment sizeFragment on Shirt {
-                size
-              }
-            |]
-                expected = HashMap.singleton "data"
-                    $ Aeson.object
-                        [ "garment" .= Aeson.object
-                            [ "circumference" .= (60 :: Int)
-                            ]
-                        ]
-            actual <- graphql (toSchema "Hat" $ garment "Hat") sourceQuery
-            actual `shouldResolveTo` expected

tests/Test/RootOperationSpec.hs

@@ -1,74 +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 Test.RootOperationSpec
-    ( spec
-    ) where
-
-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.Type
-import qualified Language.GraphQL.Type.Out as Out
-import Test.Hspec.GraphQL
-
-hatType :: Out.ObjectType IO
-hatType = Out.ObjectType "Hat" Nothing []
-    $ HashMap.singleton "circumference"
-    $ ValueResolver (Out.Field Nothing (Out.NamedScalarType int) mempty)
-    $ pure $ Int 60
-
-schema :: Schema IO
-schema = Schema
-    { query = Out.ObjectType "Query" Nothing [] hatFieldResolver
-    , mutation = Just $ Out.ObjectType "Mutation" Nothing [] incrementFieldResolver
-    , subscription = Nothing
-    }
-  where
-    garment = pure $ Object $ HashMap.fromList
-        [ ("circumference", Int 60)
-        ]
-    incrementFieldResolver = HashMap.singleton "incrementCircumference"
-        $ ValueResolver (Out.Field Nothing (Out.NamedScalarType int) mempty)
-        $ pure $ Int 61
-    hatField = Out.Field Nothing (Out.NamedObjectType hatType) mempty
-    hatFieldResolver =
-        HashMap.singleton "garment" $ ValueResolver hatField garment
-
-spec :: Spec
-spec =
-    describe "Root operation type" $ do
-        it "returns objects from the root resolvers" $ do
-            let querySource = [r|
-              {
-                garment {
-                  circumference
-                }
-              }
-            |]
-                expected = HashMap.singleton "data"
-                    $ object
-                        [ "garment" .= object
-                            [ "circumference" .= (60 :: Int)
-                            ]
-                        ]
-            actual <- graphql schema querySource
-            actual `shouldResolveTo` expected
-
-        it "chooses Mutation" $ do
-            let querySource = [r|
-              mutation {
-                incrementCircumference
-              }
-            |]
-                expected = HashMap.singleton "data"
-                    $ object
-                        [ "incrementCircumference" .= (61 :: Int)
-                        ]
-            actual <- graphql schema querySource
-            actual `shouldResolveTo` expected

tests/Test/StarWars/Data.hs

@@ -1,204 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-module Test.StarWars.Data
-    ( Character
-    , StarWarsException(..)
-    , appearsIn
-    , artoo
-    , getDroid
-    , getDroid'
-    , getEpisode
-    , getFriends
-    , getHero
-    , getHuman
-    , id_
-    , homePlanet
-    , name_
-    , secretBackstory
-    , typeName
-    ) where
-
-import Control.Monad.Catch (Exception(..), MonadThrow(..), SomeException)
-import Control.Applicative (Alternative(..), liftA2)
-import Data.Maybe (catMaybes)
-import Data.Text (Text)
-import Data.Typeable (cast)
-import Language.GraphQL.Error
-import Language.GraphQL.Type
-
--- * Data
--- See https://github.com/graphql/graphql-js/blob/master/src/__tests__/starWarsData.js
-
--- ** Characters
-
-type ID = Text
-
-data CharCommon = CharCommon
-  { _id_        :: ID
-  , _name       :: Text
-  , _friends    :: [ID]
-  , _appearsIn  :: [Int]
-  } deriving (Show)
-
-
-data Human = Human
-  { _humanChar  :: CharCommon
-  , homePlanet :: Text
-  }
-
-data Droid = Droid
-  { _droidChar       :: CharCommon
-  , primaryFunction :: Text
-  }
-
-type Character = Either Droid Human
-
-id_ :: Character -> ID
-id_ (Left  x) = _id_ . _droidChar $ x
-id_ (Right x) = _id_ . _humanChar $ x
-
-name_ :: Character -> Text
-name_ (Left  x) = _name . _droidChar $ x
-name_ (Right x) = _name . _humanChar $ x
-
-friends :: Character -> [ID]
-friends (Left  x) = _friends . _droidChar $ x
-friends (Right x) = _friends . _humanChar $ x
-
-appearsIn :: Character -> [Int]
-appearsIn (Left  x) = _appearsIn . _droidChar $ x
-appearsIn (Right x) = _appearsIn . _humanChar $ x
-
-data StarWarsException = SecretBackstory | InvalidArguments
-
-instance Show StarWarsException where
-    show SecretBackstory = "secretBackstory is secret."
-    show InvalidArguments = "Invalid arguments."
-
-instance Exception StarWarsException where
-    toException = toException . ResolverException
-    fromException e = do
-        ResolverException resolverException <- fromException e
-        cast resolverException
-
-secretBackstory :: Resolve (Either SomeException)
-secretBackstory = throwM SecretBackstory
-
-typeName :: Character -> Text
-typeName = either (const "Droid") (const "Human")
-
-luke :: Character
-luke = Right luke'
-
-luke' :: Human
-luke' = Human
-  { _humanChar = CharCommon
-      { _id_        = "1000"
-      , _name       = "Luke Skywalker"
-      , _friends    = ["1002","1003","2000","2001"]
-      , _appearsIn  = [4,5,6]
-      }
-  , homePlanet = "Tatooine"
-  }
-
-vader :: Human
-vader = Human
-  { _humanChar = CharCommon
-      { _id_        = "1001"
-      , _name       = "Darth Vader"
-      , _friends    = ["1004"]
-      , _appearsIn  = [4,5,6]
-      }
-  , homePlanet = "Tatooine"
-  }
-
-han :: Human
-han = Human
-  { _humanChar = CharCommon
-      { _id_        = "1002"
-      , _name       = "Han Solo"
-      , _friends    = ["1000","1003","2001" ]
-      , _appearsIn  = [4,5,6]
-      }
-  , homePlanet = mempty
-  }
-
-leia :: Human
-leia = Human
-  { _humanChar = CharCommon
-      { _id_        = "1003"
-      , _name       = "Leia Organa"
-      , _friends    = ["1000","1002","2000","2001"]
-      , _appearsIn  = [4,5,6]
-      }
-  , homePlanet = "Alderaan"
-  }
-
-tarkin :: Human
-tarkin = Human
-  { _humanChar = CharCommon
-    { _id_        = "1004"
-    , _name       = "Wilhuff Tarkin"
-    , _friends    = ["1001"]
-    , _appearsIn  = [4]
-    }
-  , homePlanet = mempty
-  }
-
-threepio :: Droid
-threepio = Droid
-  { _droidChar = CharCommon
-      { _id_ = "2000"
-      , _name = "C-3PO"
-      , _friends = ["1000","1002","1003","2001" ]
-      , _appearsIn = [ 4, 5, 6 ]
-      }
-  , primaryFunction = "Protocol"
-  }
-
-artoo :: Character
-artoo = Left artoo'
-
-artoo' :: Droid
-artoo' = Droid
-  { _droidChar = CharCommon
-      { _id_        = "2001"
-      , _name       = "R2-D2"
-      , _friends    = ["1000","1002","1003"]
-      , _appearsIn  = [4,5,6]
-      }
-  , primaryFunction = "Astrometch"
-  }
-
--- ** Helper functions
-
-getHero :: Int -> Character
-getHero 5 = luke
-getHero _ = artoo
-
-getHuman :: ID -> Maybe Character
-getHuman = fmap Right . getHuman'
-
-getHuman' :: ID -> Maybe Human
-getHuman' "1000" = pure luke'
-getHuman' "1001" = pure vader
-getHuman' "1002" = pure han
-getHuman' "1003" = pure leia
-getHuman' "1004" = pure tarkin
-getHuman' _      = empty
-
-getDroid :: ID -> Maybe Character
-getDroid = fmap Left . getDroid'
-
-getDroid' :: ID -> Maybe Droid
-getDroid' "2000" = pure threepio
-getDroid' "2001" = pure artoo'
-getDroid' _      = empty
-
-getFriends :: Character -> [Character]
-getFriends char = catMaybes $ liftA2 (<|>) getDroid getHuman <$> friends char
-
-getEpisode :: Int -> Maybe Text
-getEpisode 4 = pure "NEW_HOPE"
-getEpisode 5 = pure "EMPIRE"
-getEpisode 6 = pure "JEDI"
-getEpisode _ = empty

tests/Test/StarWars/QuerySpec.hs

@@ -1,366 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-module Test.StarWars.QuerySpec
-    ( spec
-    ) where
-
-import qualified Data.Aeson as Aeson
-import Data.Aeson ((.=))
-import qualified Data.HashMap.Strict as HashMap
-import Data.Text (Text)
-import Language.GraphQL
-import Text.RawString.QQ (r)
-import Test.Hspec.Expectations (Expectation, shouldBe)
-import Test.Hspec (Spec, describe, it)
-import Test.StarWars.Schema
-
--- * Test
--- See https://github.com/graphql/graphql-js/blob/master/src/__tests__/starWarsQueryTests.js
-
-spec :: Spec
-spec = describe "Star Wars Query Tests" $ do
-    describe "Basic Queries" $ do
-      it "R2-D2 hero" $ testQuery
-        [r| query HeroNameQuery {
-            hero {
-                id
-            }
-            }
-        |]
-        $ Aeson.object
-            [ "data" .= Aeson.object
-                [ "hero" .= Aeson.object ["id" .= ("2001" :: Text)]
-                ]
-            ]
-      it "R2-D2 ID and friends" $ testQuery
-        [r| query HeroNameAndFriendsQuery {
-            hero {
-                id
-                name
-                friends {
-                  name
-                }
-            }
-            }
-        |]
-        $ Aeson.object [ "data" .= Aeson.object [
-            "hero" .= Aeson.object
-                [ "id" .= ("2001" :: Text)
-                , r2d2Name
-                , "friends" .=
-                    [ Aeson.object [lukeName]
-                    , Aeson.object [hanName]
-                    , Aeson.object [leiaName]
-                    ]
-                ]
-        ]]
-
-    describe "Nested Queries" $ do
-      it "R2-D2 friends" $ testQuery
-        [r| query NestedQuery {
-              hero {
-                name
-                friends {
-                  name
-                  appearsIn
-                  friends {
-                    name
-                  }
-                }
-              }
-            }
-        |]
-        $ Aeson.object [ "data" .= Aeson.object [
-          "hero" .= Aeson.object [
-              "name" .= ("R2-D2" :: Text)
-            , "friends" .= [
-                  Aeson.object [
-                      "name" .= ("Luke Skywalker" :: Text)
-                    , "appearsIn" .= ["NEW_HOPE", "EMPIRE", "JEDI" :: Text]
-                    , "friends" .= [
-                          Aeson.object [hanName]
-                        , Aeson.object [leiaName]
-                        , Aeson.object [c3poName]
-                        , Aeson.object [r2d2Name]
-                        ]
-                    ]
-                , Aeson.object [
-                      hanName
-                    , "appearsIn" .= ["NEW_HOPE", "EMPIRE", "JEDI" :: Text]
-                    , "friends" .=
-                        [ Aeson.object [lukeName]
-                        , Aeson.object [leiaName]
-                        , Aeson.object [r2d2Name]
-                        ]
-                    ]
-                , Aeson.object [
-                      leiaName
-                    , "appearsIn" .= ["NEW_HOPE", "EMPIRE", "JEDI" :: Text]
-                    , "friends" .=
-                        [ Aeson.object [lukeName]
-                        , Aeson.object [hanName]
-                        , Aeson.object [c3poName]
-                        , Aeson.object [r2d2Name]
-                        ]
-                    ]
-                ]
-            ]
-        ]]
-      it "Luke ID" $ testQuery
-        [r| query FetchLukeQuery {
-              human(id: "1000") {
-                name
-              }
-            }
-        |]
-        $ Aeson.object [ "data" .= Aeson.object
-            [ "human" .= Aeson.object [lukeName]
-            ]]
-
-    it "Luke ID with variable" $ testQueryParams
-      (HashMap.singleton "someId" "1000")
-      [r| query FetchSomeIDQuery($someId: String!) {
-            human(id: $someId) {
-              name
-            }
-          }
-      |]
-      $ Aeson.object [ "data" .= Aeson.object [
-        "human" .= Aeson.object [lukeName]
-      ]]
-    it "Han ID with variable" $ testQueryParams
-      (HashMap.singleton "someId" "1002")
-      [r| query FetchSomeIDQuery($someId: String!) {
-            human(id: $someId) {
-              name
-            }
-          }
-      |]
-      $ Aeson.object [ "data" .= Aeson.object [
-        "human" .= Aeson.object [hanName]
-      ]]
-    it "Invalid ID" $ testQueryParams
-      (HashMap.singleton "id" "Not a valid ID")
-      [r| query humanQuery($id: String!) {
-            human(id: $id) {
-              name
-            }
-          }
-      |] $ Aeson.object ["data" .= Aeson.object ["human" .= Aeson.Null]]
-    it "Luke aliased" $ testQuery
-      [r| query FetchLukeAliased {
-            luke: human(id: "1000") {
-              name
-            }
-          }
-      |]
-      $ Aeson.object [ "data" .= Aeson.object [
-       "luke" .= Aeson.object [lukeName]
-      ]]
-    it "R2-D2 ID and friends aliased" $ testQuery
-      [r| query HeroNameAndFriendsQuery {
-            hero {
-              id
-              name
-              friends {
-                friendName: name
-              }
-            }
-          }
-      |]
-      $ Aeson.object [ "data" .= Aeson.object [
-        "hero" .= Aeson.object [
-            "id" .= ("2001" :: Text)
-          , r2d2Name
-          , "friends" .=
-              [ Aeson.object ["friendName" .= ("Luke Skywalker" :: Text)]
-              , Aeson.object ["friendName" .= ("Han Solo" :: Text)]
-              , Aeson.object ["friendName" .= ("Leia Organa" :: Text)]
-              ]
-          ]
-      ]]
-    it "Luke and Leia aliased" $ testQuery
-      [r| query FetchLukeAndLeiaAliased {
-            luke: human(id: "1000") {
-              name
-            }
-            leia: human(id: "1003") {
-              name
-            }
-          }
-      |]
-      $ Aeson.object [ "data" .= Aeson.object
-        [ "luke" .= Aeson.object [lukeName]
-        , "leia" .= Aeson.object [leiaName]
-      ]]
-
-    describe "Fragments for complex queries" $ do
-      it "Aliases to query for duplicate content" $ testQuery
-        [r| query DuplicateFields {
-              luke: human(id: "1000") {
-                name
-                homePlanet
-              }
-              leia: human(id: "1003") {
-                name
-                homePlanet
-              }
-            }
-        |]
-        $ Aeson.object [ "data" .= Aeson.object [
-          "luke" .= Aeson.object [lukeName, tatooine]
-        , "leia" .= Aeson.object [leiaName, alderaan]
-        ]]
-      it "Fragment for duplicate content" $ testQuery
-        [r|  query UseFragment {
-              luke: human(id: "1000") {
-                ...HumanFragment
-              }
-              leia: human(id: "1003") {
-                ...HumanFragment
-              }
-            }
-            fragment HumanFragment on Human {
-              name
-              homePlanet
-            }
-        |]
-        $ Aeson.object [ "data" .= Aeson.object [
-          "luke" .= Aeson.object [lukeName, tatooine]
-        , "leia" .= Aeson.object [leiaName, alderaan]
-        ]]
-
-    describe "__typename" $ do
-      it "R2D2 is a Droid" $ testQuery
-        [r| query CheckTypeOfR2 {
-              hero {
-                __typename
-                name
-              }
-            }
-          |]
-        $ Aeson.object ["data" .= Aeson.object [
-            "hero" .= Aeson.object
-                [ "__typename" .= ("Droid" :: Text)
-                , r2d2Name
-                ]
-        ]]
-      it "Luke is a human" $ testQuery
-        [r| query CheckTypeOfLuke {
-              hero(episode: EMPIRE) {
-                __typename
-                name
-              }
-            }
-          |]
-        $ Aeson.object ["data" .= Aeson.object [
-            "hero" .= Aeson.object
-                [ "__typename" .= ("Human" :: Text)
-                , lukeName
-                ]
-        ]]
-
-    describe "Errors in resolvers" $ do
-        it "error on secretBackstory" $ testQuery
-          [r|
-            query HeroNameQuery {
-              hero {
-                name
-                  secretBackstory
-              }
-            }
-          |]
-          $ Aeson.object
-              [ "data" .= Aeson.object
-                  [ "hero" .= Aeson.object
-                      [ "name" .= ("R2-D2" :: Text)
-                      , "secretBackstory" .= Aeson.Null
-                      ]
-                  ]
-              , "errors" .=
-                  [ Aeson.object
-                      ["message" .= ("secretBackstory is secret." :: Text)]
-                  ]
-              ]
-        it "Error in a list" $ testQuery
-          [r| query HeroNameQuery {
-                hero {
-                  name
-                  friends {
-                    name
-                    secretBackstory
-                  }
-                }
-              }
-            |]
-          $ Aeson.object ["data" .= Aeson.object
-            [ "hero" .= Aeson.object
-                [ "name" .= ("R2-D2" :: Text)
-                , "friends" .=
-                    [ Aeson.object
-                        [ "name" .= ("Luke Skywalker" :: Text)
-                        , "secretBackstory" .= Aeson.Null
-                        ]
-                    , Aeson.object
-                        [ "name" .= ("Han Solo" :: Text)
-                        , "secretBackstory" .= Aeson.Null
-                        ]
-                    , Aeson.object
-                        [ "name" .= ("Leia Organa" :: Text)
-                        , "secretBackstory" .= Aeson.Null
-                        ]
-                    ]
-                ]
-            ]
-            , "errors" .=
-                [ Aeson.object
-                    [ "message" .= ("secretBackstory is secret." :: Text)
-                    ]
-                , Aeson.object
-                    [ "message" .= ("secretBackstory is secret." :: Text)
-                    ]
-                , Aeson.object
-                    [ "message" .= ("secretBackstory is secret." :: Text)
-                    ]
-                ]
-            ]
-        it "error on secretBackstory with alias" $ testQuery
-          [r| query HeroNameQuery {
-                mainHero: hero {
-                  name
-                  story: secretBackstory
-                }
-              }
-            |]
-          $ Aeson.object
-              [ "data" .= Aeson.object
-                  [ "mainHero" .= Aeson.object
-                      [ "name" .= ("R2-D2" :: Text)
-                      , "story" .= Aeson.Null
-                      ]
-                  ]
-              , "errors" .=
-                  [ Aeson.object
-                    [ "message" .= ("secretBackstory is secret." :: Text)
-                    ]
-                  ]
-              ]
-
-  where
-    lukeName = "name" .= ("Luke Skywalker" :: Text)
-    leiaName = "name" .= ("Leia Organa" :: Text)
-    hanName = "name" .= ("Han Solo" :: Text)
-    r2d2Name = "name" .= ("R2-D2" :: Text)
-    c3poName = "name" .= ("C-3PO" :: Text)
-    tatooine = "homePlanet" .= ("Tatooine" :: Text)
-    alderaan = "homePlanet" .= ("Alderaan" :: Text)
-
-testQuery :: Text -> Aeson.Value -> Expectation
-testQuery q expected =
-    let Right (Right actual) = graphql schema q
-     in Aeson.Object actual `shouldBe` expected
-
-testQueryParams :: Aeson.Object -> Text -> Aeson.Value -> Expectation
-testQueryParams f q expected =
-    let Right (Right actual) = graphqlSubs schema Nothing f q
-     in Aeson.Object actual `shouldBe` expected

tests/Test/StarWars/Schema.hs

@@ -1,154 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-module Test.StarWars.Schema
-    ( schema
-    ) where
-
-import Control.Monad.Catch (MonadThrow(..), SomeException)
-import Control.Monad.Trans.Reader (asks)
-import qualified Data.HashMap.Strict as HashMap
-import Data.Maybe (catMaybes)
-import Data.Text (Text)
-import Language.GraphQL.Type
-import qualified Language.GraphQL.Type.In as In
-import qualified Language.GraphQL.Type.Out as Out
-import Test.StarWars.Data
-import Prelude hiding (id)
-
--- See https://github.com/graphql/graphql-js/blob/master/src/__tests__/starWarsSchema.js
-
-schema :: Schema (Either SomeException)
-schema = Schema
-    { query = queryType
-    , mutation = Nothing
-    , subscription = Nothing
-    }
-  where
-    queryType = Out.ObjectType "Query" Nothing [] $ HashMap.fromList
-        [ ("hero", heroFieldResolver)
-        , ("human", humanFieldResolver)
-        , ("droid", droidFieldResolver)
-        ]
-    heroField = Out.Field Nothing (Out.NamedObjectType heroObject)
-        $ HashMap.singleton "episode"
-        $ In.Argument Nothing (In.NamedEnumType episodeEnum) Nothing
-    heroFieldResolver = ValueResolver heroField hero
-    humanField = Out.Field Nothing (Out.NamedObjectType heroObject)
-        $ HashMap.singleton "id"
-        $ In.Argument Nothing (In.NonNullScalarType string) Nothing
-    humanFieldResolver = ValueResolver humanField human
-    droidField = Out.Field Nothing (Out.NamedObjectType droidObject) mempty
-    droidFieldResolver = ValueResolver droidField droid
-
-heroObject :: Out.ObjectType (Either SomeException)
-heroObject = Out.ObjectType "Human" Nothing [] $ HashMap.fromList
-    [ ("id", idFieldType)
-    , ("name", nameFieldType)
-    , ("friends", friendsFieldType)
-    , ("appearsIn", appearsInField)
-    , ("homePlanet", homePlanetFieldType)
-    , ("secretBackstory", secretBackstoryFieldType)
-    , ("__typename", typenameFieldType)
-    ]
-  where
-    homePlanetFieldType
-      = ValueResolver (Out.Field Nothing (Out.NamedScalarType string) mempty)
-      $ idField "homePlanet"
-
-droidObject :: Out.ObjectType (Either SomeException)
-droidObject = Out.ObjectType "Droid" Nothing [] $ HashMap.fromList
-    [ ("id", idFieldType)
-    , ("name", nameFieldType)
-    , ("friends", friendsFieldType)
-    , ("appearsIn", appearsInField)
-    , ("primaryFunction", primaryFunctionFieldType)
-    , ("secretBackstory", secretBackstoryFieldType)
-    , ("__typename", typenameFieldType)
-    ]
-  where
-    primaryFunctionFieldType
-        = ValueResolver (Out.Field Nothing (Out.NamedScalarType string) mempty)
-        $ idField "primaryFunction"
-
-typenameFieldType :: Resolver (Either SomeException)
-typenameFieldType
-    = ValueResolver (Out.Field Nothing (Out.NamedScalarType string) mempty)
-    $ idField "__typename"
-
-idFieldType :: Resolver (Either SomeException)
-idFieldType
-    = ValueResolver (Out.Field Nothing (Out.NamedScalarType id) mempty)
-    $ idField "id"
-
-nameFieldType :: Resolver (Either SomeException)
-nameFieldType
-    = ValueResolver (Out.Field Nothing (Out.NamedScalarType string) mempty)
-    $ idField "name"
-
-friendsFieldType :: Resolver (Either SomeException)
-friendsFieldType
-    = ValueResolver (Out.Field Nothing fieldType mempty)
-    $ idField "friends"
-  where
-    fieldType = Out.ListType $ Out.NamedObjectType droidObject
-
-appearsInField :: Resolver (Either SomeException)
-appearsInField
-    = ValueResolver (Out.Field (Just description) fieldType mempty)
-    $ idField "appearsIn"
-  where
-    fieldType = Out.ListType $ Out.NamedEnumType episodeEnum
-    description = "Which movies they appear in."
-
-secretBackstoryFieldType :: Resolver (Either SomeException)
-secretBackstoryFieldType = ValueResolver field secretBackstory
-  where
-    field = Out.Field Nothing (Out.NamedScalarType string) mempty
-
-idField :: Text -> Resolve (Either SomeException)
-idField f = do
-    v <- asks values
-    let (Object v') = v
-    pure $ v' HashMap.! f
-
-episodeEnum :: EnumType
-episodeEnum = EnumType "Episode" (Just description)
-    $ HashMap.fromList [newHope, empire, jedi]
-  where
-    description = "One of the films in the Star Wars Trilogy"
-    newHope = ("NEW_HOPE", EnumValue $ Just "Released in 1977.")
-    empire = ("EMPIRE", EnumValue $ Just "Released in 1980.")
-    jedi = ("JEDI", EnumValue $ Just "Released in 1983.")
-
-hero :: Resolve (Either SomeException)
-hero = do
-  episode <- argument "episode"
-  pure $ character $ case episode of
-      Enum "NEW_HOPE" -> getHero 4
-      Enum "EMPIRE" -> getHero 5
-      Enum "JEDI" -> getHero 6
-      _ -> artoo
-
-human :: Resolve (Either SomeException)
-human = do
-    id' <- argument "id"
-    case id' of
-        String i -> pure $ maybe Null character $ getHuman i >>= Just
-        _ -> throwM InvalidArguments
-
-droid :: Resolve (Either SomeException)
-droid = do
-    id' <- argument "id"
-    case id' of
-        String i -> pure $ maybe Null character $ getDroid i >>= Just
-        _ -> throwM InvalidArguments
-
-character :: Character -> Value
-character char = Object $ HashMap.fromList
-    [ ("id", String $ id_ char)
-    , ("name", String $ name_ char)
-    , ("friends", List $ character <$> getFriends char)
-    , ("appearsIn", List $ Enum <$> catMaybes (getEpisode <$> appearsIn char))
-    , ("homePlanet", String $ either mempty homePlanet char)
-    , ("__typename", String $ typeName char)
-    ]