GraphQL

Working Draft – July 2015

Introduction

This is a Draft RFC Specification for GraphQL, a query language created by Facebook in 2012 for describing the capabilities and requirements of data models for client‐server applications. The development of this standard started in 2015. GraphQL is a new and evolving language and is not complete. Significant enhancement will continue in future editions of this specification.

Copyright notice

Copyright (c) 2015, Facebook, Inc. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  1. 1Overview
  2. 2Language
    1. 2.1Document
    2. 2.2Operations
    3. 2.3Fields
    4. 2.4Field Selections
    5. 2.5Field Arguments
    6. 2.6Field Alias
    7. 2.7Input Values
    8. 2.8Variables
    9. 2.9Directives
    10. 2.10Fragments
      1. 2.10.1Types on fragments
      2. 2.10.2Query variables in fragments
      3. 2.10.3Inline fragments
  3. 3Type System
    1. 3.1Types
      1. 3.1.1Scalars
        1. 3.1.1.1Built-in Scalars
          1. 3.1.1.1.1Int
          2. 3.1.1.1.2Float
          3. 3.1.1.1.3String
          4. 3.1.1.1.4Boolean
          5. 3.1.1.1.5ID
      2. 3.1.2Objects
        1. 3.1.2.1Object Field Arguments
        2. 3.1.2.2Object Field deprecation
        3. 3.1.2.3Object type validation
      3. 3.1.3Interfaces
        1. 3.1.3.1Interface type validation
      4. 3.1.4Unions
        1. 3.1.4.1Union type validation
      5. 3.1.5Enums
      6. 3.1.6Input Objects
      7. 3.1.7Lists
      8. 3.1.8Non-Null
    2. 3.2Directives
    3. 3.3Starting types
  4. 4Introspection
    1. 4.1General Principles
      1. 4.1.1Naming conventions
      2. 4.1.2Documentation
      3. 4.1.3Deprecation
      4. 4.1.4Type Name Introspection
    2. 4.2Schema Introspection
      1. 4.2.1The "__Type" Type
      2. 4.2.2Type Kinds
        1. 4.2.2.1Scalar
        2. 4.2.2.2Object
        3. 4.2.2.3Union
        4. 4.2.2.4Interface
        5. 4.2.2.5Enum
        6. 4.2.2.6Input Object
        7. 4.2.2.7List
        8. 4.2.2.8Non-null
        9. 4.2.2.9Combining List and Non-Null
  5. 5Validation
    1. 5.1Fields
      1. 5.1.1Field Selections on Objects, Interfaces, and Unions Types
      2. 5.1.2Field Selection Merging
      3. 5.1.3Leaf Field Selections
    2. 5.2Arguments
      1. 5.2.1Argument Names
      2. 5.2.2Argument Values Type Correctness
        1. 5.2.2.1Compatible Values
        2. 5.2.2.2Argument Optionality
    3. 5.3Fragments
      1. 5.3.1Fragment Declarations
        1. 5.3.1.1Fragment Spread Type Existence
        2. 5.3.1.2Fragments On Composite Types
        3. 5.3.1.3Fragments Must Be Used
      2. 5.3.2Fragment Spreads
        1. 5.3.2.1Fragment spread target defined
        2. 5.3.2.2Fragment spreads must not form cycles
        3. 5.3.2.3Fragment spread is possible
          1. 5.3.2.3.1Object Spreads In Object Scope
          2. 5.3.2.3.2Abstract Spreads in Object Scope
          3. 5.3.2.3.3Object Spreads In Abstract Scope
          4. 5.3.2.3.4Abstract Spreads in Abstract Scope
    4. 5.4Directives
      1. 5.4.1Directives Are Defined
      2. 5.4.2Directive Arguments Are Of Correct Type
    5. 5.5Operations
      1. 5.5.1Variables
        1. 5.5.1.1Variable Default Values Are Correctly Typed
        2. 5.5.1.2Variables Are Input Types
        3. 5.5.1.3All Variable Uses Defined
        4. 5.5.1.4All Variables Used
        5. 5.5.1.5All Variable Usages are Allowed
  6. 6Execution
    1. 6.1Evaluating requests
    2. 6.2Evaluating operations
    3. 6.3Evaluating selection sets
    4. 6.4Evaluating a grouped field set
      1. 6.4.1Field entries
      2. 6.4.2Normal evaluation
      3. 6.4.3Serial execution
      4. 6.4.4Error handling
      5. 6.4.5Nullability
  7. 7Response
    1. 7.1Serialization Format
      1. 7.1.1JSON Serialization
    2. 7.2Response Format
      1. 7.2.1Data
      2. 7.2.2Errors
  8. 8Grammar
    1. 8.1Tokens
      1. 8.1.1Ignored Source
    2. 8.2Syntax
      1. 8.2.1Document
      2. 8.2.2Operations
      3. 8.2.3Fragments
      4. 8.2.4Values
        1. 8.2.4.1Array Value
        2. 8.2.4.2Object Value
      5. 8.2.5Directives
      6. 8.2.6Types

1Overview

GraphQL is a query language designed to build client applications by providing an intuitive and flexible syntax and system for describing their data requirements and interactions.

For example, this GraphQL request will receive the name of the user with id 4 from the Facebook implementation of GraphQL.

{
  user(id: 4) {
    name
  }
}

Which produces the resulting data (in JSON):

{
  "user": {
    "name": "Mark Zuckerberg"
  }
}

GraphQL is not a programming language capable of arbitrary computation, but is instead a language used to query application servers that have capabilities defined in this specification. GraphQL does not mandate a particular programming language or storage system for application servers that implement it. Instead, application servers take their capabilities and map them to a uniform language, type system, and philosophy that GraphQL encodes. This provides a unified interface friendly to product development and a powerful platform for tool‐building.

GraphQL has a number of design principles:

Because of these principles, GraphQL is a powerful and productive environment for building client applications. Product developers and designers building applications against working GraphQL servers -- supported with quality tools -- can quickly become productive without reading extensive documentation and with little or no formal training. To enable that experience, there must be those that build those servers and tools.

The following formal specification serves as a reference for those builders. It describes the language and its grammar; the type system and the introspection system used to query it; and the execution and validation engines with the algorithms to power them. The goal of this specification is to provide a foundation and framework for an ecosystem of GraphQL tools, client libraries, and server implementations -- spanning both organizations and platforms -- that has yet to be built. We look forward to working with the community in order to do that.

2Language

Clients use the GraphQL language to make requests from a GraphQL server. We refer to these requests as documents. A document may contain operations (queries and mutations are both operations) and fragments, a common unit of composition allowing for query reuse.

2.1Document

GraphQL documents are only executable by a server if they contain an operation. However documents which do not contain operations may still be parsed and validated to allow client to represent a single request across many documents.

GraphQL documents may contain multiple operations, as long as they are named. When submitting a document with multiple operations to a GraphQL server, the name of the desired operation must also be provided.

If a document contains only one query operation, that operation may be represented in the shorthand form, which omits the query keyword and query name.

2.2Operations

There are two types of operations that GraphQL models:

Each operation is represented by a custom name and a selection of fields.

Query shorthand

If a query has no variables or directives or name, the query keyword can be omitted. This means it must be the only query in the document.

many examples below will use the query shorthand syntax.

2.3Fields

A field in the top‐level selection set often represents some kind of information that is globally accessible to your application and the current viewer. Some typical examples of global fields:

# `me` could represent the currently logged in user.
query getMe {
  me { /* ... */ }
}

# `user` represents one of many users in a graph of data.
query getZuck {
  user(id: 4) { /* ... */ }
}

2.4Field Selections

Each field is of a specific type, and the sub‐fields must always be explicitly declared via a field selection, unless it is a scalar. For example, when fetching data from some user object:

query getZuck {
  user(id: 4) {
    id,
    firstName,
    lastName
  }
}

Field selections can be further composed to explicitly state all subfields of nested types. All queries must specify down to scalar fields.

query getZuck {
  user(id: 4) {
    id,
    firstName,
    lastName,
    birthday {
      month,
      day
    }
  }
}

2.5Field Arguments

Fields may take arguments. These often map directly to function arguments within the GraphQL server implementation. We already saw arguments used in the global field above.

In this example, we want to query a user’s profile picture of a specific size:

{
  user(id: 4) {
    id,
    name,
    profilePic(size: 100)
  }
}

Many arguments can exist for a given field:

{
  user(id: 4) {
    id,
    name,
    profilePic(width: 100, height: 50)
  }
}

Arguments are unordered

Field arguments may be provided in any syntactic order and maintain identical semantic meaning.

These two queries are semantically identical:

{
  picture(width: 200, height: 100)
}
{
  picture(height: 100, width: 200)
}

2.6Field Alias

By default, the key in the response object will use the field name queried. However, you can define a different name by specifying an alias.

In this example, we can fetch two profile pictures of different sizes and ensure the resulting object will not have duplicate keys:

{
  user(id: 4) {
    id,
    name,
    smallPic: profilePic(size: 64),
    bigPic: profilePic(size: 1024)
  }
}

Which returns the result:

{
  "user": {
    "id": 4,
    "name": "Mark",
    "smallPic": "https://cdn.site.io/pic-4-64.jpg",
    "bigPic": "https://cdn.site.io/pic-4-1024.jpg"
  }
}

Since the top level of a query is a field, it also can be given an alias:

{
  zuck: user(id: 4) {
    id
    name
  }
}

Returns the result:

{
  "zuck": {
    "id": 4,
    "name": "Mark Zuckerberg"
  }
}

A field’s response key is its alias if an alias is provided, and it is the field’s name otherwise.

2.7Input Values

Both field arguments and directives accept input values. Input values can be specified as a variable or respresented inline as literals. Input values can be scalars, enumerations, or input objects. List and inputs objects may also contain variables.

Int

Int is a number specified without a decimal point (ex. 1).

Float

A Float numbers always includes a decimal point (ex. 1.0) and may optionally also include an exponent (ex. 6.0221413e23).

Boolean

The two keywords true and false represent the two boolean values.

String

Strings are lists of characters wrapped in double‐quotes ". (ex. "Hello World"). Whitespace is significant within a string.

Enum Value

Enum values are respresented as unquoted names (ex. MOBILE_WEB). It is recommended that Enum values be “all caps”. Enum values are only used in contexts where the precise enumeration type is known. Therefore it’s not necessary to use the enumeration type name in the literal.

List

Lists are an ordered sequence of values wrapped in square‐brackets [ ]. The values of an Array literal may be any value literal or variable (ex. [1, 2, 3]).

Commas are optional throughout GraphQL so trailing commas are allowed and repeated commas do not represent missing values.

Input Object

Input object literals are un‐ordered lists of keyed input values wrapped in curly‐braces { }. The values of an object literal may be any input value literal or variable (ex. { name: "Hello world", score: 1.0 }). We refer to literal representation of input objects as “object literals.”

2.8Variables

A GraphQL query can be parameterized with variables, maximizing query reuse, and avoiding costly string building in clients at runtime.

Variables must be defined at the top of an operation and have global scope.

In this example, we want to fetch a profile picture size based on the size of a particular device:

query getZuckProfile($devicePicSize: Int) {
  user(id: 4) {
    id,
    name,
    profilePic(size: $devicePicSize)
  }
}

Values for those variables are provided along with a GraphQL query, so they may be substituted during execution. If providing JSON for the variables values, we could run this query and request profilePic of size 60 with:

{
  "devicePicSize": 60
}

2.9Directives

In some cases, you need to provide options to alter GraphQL’s execution behavior in ways field arguments will not suffice, such as conditionally skipping a field. Directives provide this with a @name and can be specified to be used without an argument or with a value argument.

Directives can be used to conditionally include fields in a query based on a provided boolean value. In this contrived example experimentalField will be queried and controlField will not.

query myQuery($someTest: Boolean) {
  experimentalField @if: $someTest
  controlField @unless: $someTest
}

As future versions of GraphQL adopts new configurable execution capabilities, they may be exposed via directives.

2.10Fragments

Fragments allow for reuse of repeated portions of a query. It is the unit of composition in GraphQL.

For example, if we wanted to fetch some common information about mutual friends as well as friends of some user:

query noFragments
{
  user(id: 4) {
    friends(first: 10) {
      id
      name
      profilePic(size: 50)
    }
    mutualFriends(first: 10) {
      id
      name
      profilePic(size: 50)
    }
  }
}

The repeated fields could be extracted into a fragment and composed by a parent fragment or query.

query withFragments {
  user(id: 4) {
    friends(first: 10) { ...friendFields }
    mutualFriends(first: 10) { ...friendFields }
  }
}

fragment friendFields on User {
  id
  name
  profilePic(size: 50)
}

Fragments are consumed by using the spread operator (...). All fields selected by the fragment will be added to the query field selection at the same level as the fragment invocation. This happens through multiple levels of fragment spreads.

For example:

query withNestedFragments
{
  user(id: 4) {
    friends(first: 10) { ...friendFields }
    mutualFriends(first: 10) { ...friendFields }
  }
}

fragment friendFields on User {
  id
  name
  ..standardProfilePic
}

fragment standardProfilePic on User {
  profilePic(size: 50)
}

The queries noFragments, withFragments, and withNestedFragments all produce the same response object.

2.10.1Types on fragments

Fragments must specify the type they apply to. In this example, friendFields can be used in the context of querying a User.

Fragments cannot be specified on any input value (scalar, enumeration, or input object).

Fragments can be specified on object types, interfaces, and unions.

Selections within fragments only return values when concrete type of the object it is operating on matches the type of the fragment.

For example in this query on the Facebook data model:

query FragmentTyping
{
  profiles(handles: ["zuck", "cocacola"]) {
    handle
    ...userFragment
    ...pageFragment
  }
}

fragment userFragment on User {
  friends { count }
}

fragment pageFragment on Page {
  likers { count }
}

The profiles root field returns a list where each element could be a Page or a User. When the object in the profiles result is a User, friends will be present and likers will not. Conversely when the result is a Page, likers will be present and friends will not.

{
  "profiles" : [
    {
      "handle" : "zuck",
      "friends" : { "count" : 1234 }
    },
    {
      "handle" : "cocacola",
      "likers" : { "count" : 90234512 }
    }
  ]
}

2.10.2Query variables in fragments

Query variables can be used within fragments. Query variables have global scope with a given operation, so a variable used within a fragment must be declared in any top‐level operation that transitively consumes that fragment. If variable is referenced in a fragment and is included by an operation that does not define that variable, the operation cannot be executed.

2.10.3Inline fragments

Fragments can be defined inline to query. This is done to conditionally execute fields based on their runtime type. This feature of standard fragment inclusion was demonstrated in the query FragmentTyping example. We could accomplish the same thing using inline fragments.

query InlineFragmentTyping {
  profiles(handles: ["zuck", "cocacola"]) {
    handle
    ... on User {
      friends { count }
    }
    ... on Page {
      likers { count }
    }
  }
}

3Type System

The GraphQL Type system describes the capabilities of a GraphQL server and is used to determine if a query is valid. The type system also describes the input types of query variables to determine if values provided at runtime are valid.

A GraphQL server’s capabilities are referred to as that server’s “schema”. A schema is defined in terms of the types and directives it supports.

A given GraphQL schema must itself be internally valid. This section describes the rules for this validation process where relevant.

A GraphQL schema is represented by a root type for each kind of operation: query and mutation; this determines the place in the type system where those operations begin.

All types within a GraphQL schema must have unique names. No two provided types may have the same name. No provided type may have a name which conflicts with any built in types (including Scalar and Introspection types).

All directives within a GraphQL schema must have unique names. A directive and a type may share the same name, since there is no ambiguity between them.

3.1Types

The fundamental unit of any GraphQL Schema is the type. There are eight kinds of types in GraphQL.

The most basic type is a Scalar. A scalar represents a primitive value, like a string or an integer. Oftentimes, the possible responses for a scalar field are enumerable. GraphQL offers an Enum type in those cases, where the type specifies the space of valid responses.

Scalars and Enums form the leaves in response trees; the intermediate levels are Object types, which define a set of fields, where each field is another type in the system, allowing the definition of arbitrary type hierarchies.

GraphQL supports two abstract types: interfaces and unions.

An Interface defines a list of fields; Object types that implement that interface are guaranteed to implement those fields. Whenever the type system claims it will return an interface, it will return a valid implementating type.

A Union defines a list of possible types; similar to interfaces, whenever the type system claims a union will be returned, one of the possible types will be returned.

All of the types so far are assumed to be both nullable and singular: e.g. a scalar string returns either null or a singular string. The type system might want to define that it returns a list of other types; the List type is provided for this reason, and wraps another type. Similarly, the Non-Null type wraps another type, and denotes that the result will never be null. These two types are refered to as “wrapping types”; non‐wrapping types are refered to as “base types”. A wrapping type has an underlying “base type”, found by continually unwrapping the type until a base type is found.

Finally, oftentimes it is useful to provide complex structs as inputs to GraphQL queries; the Input Object type allows the schema to define exactly what data is expected from the client in these queries.

3.1.1Scalars

As expected by the name, a scalar represents a primitive value in GraphQL. GraphQL responses take the form of a hierarchal tree; the leaves on these trees are GraphQL scalars.

All GraphQL scalars are representable as strings, though depending on the response format being used, there may be a more appropriate primitive for the given scalar type, and server should use those types when appropriate.

GraphQL provides a number of built‐in scalars, but type systems can add additional scalars with semantic meaning. For example, a GraphQL system could define a scalar called Time which, while serialized as a string, promises to conform to ISO‐8601. When querying a field of type Time, you can then rely on the ability to parse the result with an ISO‐8601 parser and use a client‐specific primitive for time. Another example of a potentially useful custom scalar is Url, which serializes as a string, but is guaranteed by the server to be a valid URL.

Result Coercion

A GraphQL server, when preparing a field of a given scalar type, must uphold the contract the scalar type describes, either by coercing the value or producing an error.

For example, a GraphQL server could be preparing a field with the scalar type Int and encounter a floating‐point number. Since the server must not break the contract by yielding a non‐integer, the server should truncate the fractional value and only yield the integer value. If the server encountered a boolean true value, it should return 1. If the server encountered a string, it may attempt to parse the string for a base‐10 integer value. If the server encounters some value that cannot be reasonably coerced to an Int, then it must raise an field error.

Since this coercion behavior is not observable to clients of the GraphQL server, the precise rules of coercion are left to the implementation. The only requirement is that the server must yield values which adhere to the expected Scalar type.

Input Coercion

If a GraphQL server expects a scalar type as input to a field argument, coercion is observable and the rules must be well defined. If an input value does not match a coercion rule, a query error must be raised.

GraphQL has different constant literals to represent integer and floating‐point input values, and coercion rules may apply differently depending on which type of input value is encountered. GraphQL may be parameterized by query variables, the values of which are often serialized when sent over a transport like HTTP. Since some common serializations (ex. JSON) do not discriminate between integer and floating‐point values, they are interpretted as an integer input value if they have an empty fractional part (ex. 1.0) and otherwise as floating‐point input value.

3.1.1.1Built-in Scalars

GraphQL provides a basic set of well‐defined Scalar types. A GraphQL server should support all of these types, and a GraphQL server which provide a type by these names must adhere to the behavior described below.

3.1.1.1.1Int

The Int scalar type represents a signed 32‐bit numeric non‐fractional values. Response formats that support a 32‐bit integer or a number type should use that type to represent this scalar.

Result Coercion

GraphQL servers should coerce non‐int raw values to Int when possible otherwise they must raise a field error. Examples of this may include returning 1 for the floating‐point number 1.0, or 2 for the string "2".

Input Coercion

When expected as an input type, only integer input values are accepted. All other input values, including strings with numeric content, must raise a query error indicating an incorrect type. If the integer input value represents a value less than -231 or greater than or equal to 231, a query error should be raised.

Numeric integer values larger than 32‐bit should either use String or a custom‐defined Scalar type, as not all platforms and transports support encoding integer numbers larger than 32‐bit.
3.1.1.1.2Float

The Float scalar type represents signed double‐precision fractional values as specified by IEEE 754. Response formats that support an appropriate double‐precision number type should use that type to represent this scalar.

Result Coercion

GraphQL servers should coerce non‐floating‐point raw values to Float when possible otherwise they must raise a field error. Examples of this may include returning 1.0 for the integer number 1, or 2.0 for the string "2".

Input Coercion

When expected as an input type, both integer and float input values are accepted. Integer input values are coerced to Float by adding an empty fractional part, for example 1.0 for the integer input value 1. All other input values, including strings with numeric content, must raise a query error indicating an incorrect type. If the integer input value represents a value not representable by IEEE 754, a query error should be raised.

3.1.1.1.3String

The String scalar type represents textual data, represented as UTF‐8 character sequences. The String type is most often used by GraphQL to represent free‐form human‐readable text. All response formats must support string representations, and that representation must be used here.

Result Coercion

GraphQL servers should coerce non‐string raw values to String when possible otherwise they must raise a field error. Examples of this may include returning the string "true" for a boolean true value, or the string "1" for the integer 1.

Input Coercion

When expected as an input type, only valid UTF‐8 string input values are accepted. All other input values must raise a query error indicating an incorrect type.

3.1.1.1.4Boolean

The Boolean scalar type represents true or false. Response formats should use a built‐in boolean type if supported; otherwise, they should use their representation of the integers 1 and 0.

Result Coercion

GraphQL servers should coerce non‐boolean raw values to Boolean when possible otherwise they must raise a field error. Examples of this may include returning true for any non‐zero number.

Input Coercion

When expected as an input type, only boolean input values are accepted. All other input values must raise a query error indicating an incorrect type.

3.1.1.1.5ID

The ID scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type is serialized in the same way as a String; however, it is not intended to be human‐readable. While it is often numeric, it should always serialize as a String.

Result Coercion

GraphQL is agnostic to ID format, and serializes to string to ensure consistency across many formats ID could represent, from small auto‐increment numbers, to large 128‐bit random numbers, to base64 encoded values, or string values of a format like GUID.

GraphQL servers should coerce as appropriate given the ID formats they expect, when coercion is not possible they must raise a field error.

Input Coercion

When expected as an input type, any string (such as "4") or integer (such as 4) input value should be coerced to ID as appropriate for the ID formats a given GraphQL server expects. Any other input value, including float input values (such as 4.0), must raise a query error indicating an incorrect type.

3.1.2Objects

GraphQL queries are hierarchal and composed, describing a tree of information. While Scalar types describe the leaf values of these hierarchal queries, Objects describe the intermediate levels.

GraphQL Objects represent a list of named fields, each of which yield a value of a specific type. Object values are serialized as unordered maps, where the queried field names (or aliases) are the keys and the result of evaluating the field is the value.

For example, a type Person could be described as:

type Person {
  name: String
  age: Int
  picture: Url
}

Where name is a field that will yield a String value, and age is a field that will yield an Int value, and picture a field that will yield a Url value.

A query of an object value must select at least one field. This selection of fields will yield an unordered map containing exactly the subset of the object queried. Only fields that are declared on the object type may validly be queried on that object.

For example, selecting all the fields of Person:

{
  name,
  age,
  picture
}

Would yield the object:

{
  "name": "Mark Zuckerberg",
  "age": 30,
  "picture": "http://some.cdn/picture.jpg"
}

While selecting a subset of fields:

{
  name,
  age
}

Must only yield exactly that subset:

{
  "name": "Mark Zuckerberg",
  "age": 30
}

A field of an Object type may be a Scalar, Enum, another Object type, an Interface, or a Union. Additionally, it may be any wrapping type whose underlying base type is one of those five.

For example, the Person type might include a relationship:

type Person {
  name: String
  age: Int
  picture: Url
  relationship: Person
}

Valid queries must supply a nested field set for a field that returns an object, so this query is not valid:

{
  name,
  relationship
}

However, this example is valid:

{
  name,
  relationship {
    name
  }
}

And will yield the subset of each object type queried:

{
  "name": "Mark Zuckerberg",
  "relationship": {
    "name": "Priscilla Chan"
  }
}

Result Coercion

Determining the result of coercing an object is the heart of the GraphQL executor, so this is covered in that section of the spec.

Input Coercion

Objects are never valid inputs.

3.1.2.1Object Field Arguments

Object fields are conceptually functions which yield values. Occasionally object fields can accept arguments to further specify the return value. Field arguments are defined as a list of all possible argument names and their expected input types.

For example, a Person type with a picture field could accept an argument to determine what size of an image to return.

type Person {
  name: String
  picture(size: Int): Url
}

GraphQL queries can optionally specify arguments to their fields to provide these arguments.

This example query:

{
  name,
  picture(size: 600)
}

May yield the result:

{
  "name": "Mark Zuckerberg",
  "picture": "http://some.cdn/picture_600.jpg"
}

The type of a field argument can be a Scalar, as it was in this example, or an Enum. It can also be an Input Object, covered later in this document, or it can be any wrapping type whose underlying base type is one of those three.

3.1.2.2Object Field deprecation

Fields in an object may be marked as deprecated as deemed necessary by the application. It is still legal to query for these fields (to ensure existing clients are not broken by the change), but the fields should be appropriately treated in documentation and tooling.

3.1.2.3Object type validation

Object types have the potential to be invalid if incorrectly defined. This set of rules must be adhered to by every Object type in a GraphQL schema.

  1. The fields of an Object type must have unique names within that Object type; no two fields may share the same name.
  2. An object type must be a super‐set of all interfaces it implements.
    1. The object type must include a field of the same name for every field defined in an interface.
      1. The object field must include an argument of the same name for every argument defined by the interface field.
        1. The object field argument must accept the same type (invariant) as the interface field argument.
      2. The object field must be of a type which is equal to the interface field.

3.1.3Interfaces

GraphQL Interfaces represent a list of named fields and their arguments. GraphQL object can then implement an interface, which guarantees that they will contain the specified fields.

Fields on a GraphQL interface have the same rules as fields on a GraphQL object; their type can be Scalar, Object, Enum, Interface, or Union, or any wrapping type whose base type is one of those five.

For example, a interface may describe a required field and types such as Person or Business may then implement this interface.

interface NamedEntity {
  name: String
}

type Person : NamedEntity {
  name: String
  age: Int
}

type Business : NamedEntity {
  name: String
  employeeCount: Int
}

Fields which yield an interface are useful when one of many Object types are expected, but some fields should be guaranteed.

To continue the example, a Contact might refer to NamedEntity.

type Contact {
  entity: NamedEntity
  phoneNumber: String
  address: String
}

This allows us to write a query for a Contact that can select the common fields.

{
  entity {
    name
  },
  phoneNumber
}

When querying for fields on an interface type, only those fields declared on the interface may be queried. In the above example, entity returns a NamedEntity, and name is defined on NamedEntity, so it is valid. However, the following would not be a valid query:

{
  entity {
    name,
    age
  },
  phoneNumber
}

because entity refers to a NamedEntity, and age is not defined on that interface. Querying for age is only valid when the result of entity is a Person; the query can express this using a fragment or an inline fragment:

{
  entity {
    name,
    ... on User {
      age
    }
  },
  phoneNumber
}

Result Coercion

The interface type should have some way of determining which object a given result corresponds to. Once it has done so, the result coercion of the interface is the same as the result coercion of the object.

Input Coercion

Interfaces are never valid inputs.

3.1.3.1Interface type validation

Interface types have the potential to be invalid if incorrectly defined.

  1. The fields of an Interface type must have unique names within that Interface type; no two fields may share the same name.

3.1.4Unions

GraphQL Unions represent an object that could be one of a list of GraphQL Object types, but provides for no guaranteed fields between those types. They also differ from interfaces in that Object types declare what interfaces they implement, but are not aware of what unions contain them.

With interfaces and objects, only those fields defined on the type can be queried directly; to query other fields on an interface, typed fragments must be used. This is the same as for unions, but unions do not define any fields, so no fields may be queried on this type without the use of typed fragments.

For example, we might have the following type system:

Union SearchResult = Photo | Person

type Person {
  name: String
  age: Int
}

type Photo {
  height: Int
  width: Int
}

type SearchQuery {
  firstSearchResult: SearchResult
}

When querying the firstSearchResult field of type SearchQuery, the query would ask for all fields inside of a fragment indicating the appropriate type. If the query wanted the name if the result was a Person, and the height if it was a photo, the following query is invalid, because the union itself defines not fields:

{
  firstSearchResult {
    name
    height
  }
}

Instead, the query would be:

{
  firstSearchResult {
    ... on Person {
      name
    }
    ... on Photo {
      height
    }
  }
}

Result Coercion

The union type should have some way of determining which object a given result corresponds to. Once it has done so, the result coercion of the union is the same as the result coercion of the object.

Input Coercion

Unions are never valid inputs.

3.1.4.1Union type validation

Union types have the potential to be invalid if incorrectly defined.

  1. The member types of an Union type must all be Object base types; Scalar, Interface and Union types may not be member types of a Union. Similarly, wrapping types may not be member types of a Union.
  2. A Union type must define two or more member types.

When expected as an input type, array input values are accepted only when each item in the input array can be accepted by the item type. If the input value is not an array but can be accepted by the item type, it is coerced by creating an array with the input value as the sole item. Other input values must raise a query error indicating an incorrect type.

3.1.5Enums

GraphQL Enums are a variant on the Scalar type, which represents one of a finite set of possible values.

GraphQL Enums are not references for a numeric value, but are unique values in their own right. They serialize as a string: the name of the represented value.

Result Coercion

GraphQL servers must return one of the defined set of possible values, if a reasonable coercion is not possible they must raise a field error.

Input Coercion

GraphQL has a constant literal to represent enum input values. GraphQL string literals must not be accepted as an enum input and instead raise a query error.

Query variable transport serializations which have a different representation for non‐string symbolic values (for example, EDN) should only allow such values as enum input values. Otherwise, for most transport serializations that do not, strings may be interpretted as the enum input value with the same name.

3.1.6Input Objects

Fields can define arguments that the client passes up with the query, to configure their behavior. These inputs can be Strings or Enums, but they sometimes need to be more complex than this.

The Object type defined above is inappropriate for re‐use here, because Objects can contain fields that express circular references or references to interfaces and unions, neither of which is appropriate for use as an input argument. For this reason, input objects have a separate type in the system.

An Input Object defines a set of input fields; the input fields are either scalars, enums, or other input objects. This allows arguments to accept arbitrarily complex structs.

Result Coercion

An input object is never a valid result.

Input Coercion

The input to an input object should be an unordered map, otherwise an error should be thrown. The result of the coercion is an unordered map, with an entry for each input field, whose key is the name of the input field. The value of an entry in the coerced map is the result of input coercing the value of the entry in the input with the same key; if the input does not have a corresponding entry, the value is the result of coercing null. The input coercion above should be performed according to the input coercion rules of the type declared by the input field.

3.1.7Lists

A GraphQL list is a special collection type which declares the type of each item in the List (referred to as the item type of the list). List values are serialized as ordered lists, where each item in the array is serialized as per the item type.

Result Coercion

GraphQL servers must return an ordered list as the result of a list type. Each item in the list must be the result of a result coercion of the item type. If a reasonable coercion is not possible they must raise a field error. In particular, if a non‐list is returned, the coercion should fail, as this indicates a mismatch in expectations between the type system and the implementation.

Input Coercion

When accepted as an input, each item in the list should be coerced as per the input coercion of the item type.

If the value passed as an input to a list type is not as list, it should be coerced as though the input was a list of size one, where the value passed is the only item in the list. This is to allow inputs that accept a “var args” to declare their input type as a list; if only one argument is passed (a common case), the client can just pass that value rather than constructing the list.

3.1.8Non-Null

By default, all types in GraphQL are nullable; the null value is a valid response for all of the above types. To declare a type that disallows null, the GraphQL Non‐Null type can be used. This type declares an underlying type, and this type acts identically to that underlying type, with the exception that null is not a valid response for the wrapping type.

Result Coercion

In all of the above result coercion, null was considered a valid value. To coerce the result of a Non Null type, the result coercion of the underlying type should be performed. If that result was not null, then the result of coercing the Non Null type is that result. If that result was null, then an error should be raised.

Input Coercion

When accepted as an input, each item in the list should be coerced as per the input coercion of the item type.

If the value passed as an input to a list type is not as list, it should be coerced as though the input was a list of size one, where the value passed is the only item in the list. This is to allow inputs that accept a “var args” to declare their input type as a list; if only one argument is passed (a common case), the client can just pass that value rather than constructing the list.

3.2Directives

A GraphQL schema includes a list of supported directives, each of which has a name. Directives can apply to operations, fragments, or fields; each directive indicates which of those it applies to.

Directives can optionally take an argument. The type of the argument to a directive has the same restrictions as the type of an argument to a field. It can be a Scalar, an Enum, an Input Object, or any wrapping type whose underlying base type is one of those three.

3.3Starting types

A GraphQL schema includes types, indicating where query and mutation operations start. This provides the initial entry points into the type system. The query type must always be provided, and is an Object base type. The mutation type is optional; if it is null, that means the system does not support mutations. If it is provided, it must be an object base type.

The fields on the query type indicate what fields are available at the top level of a GraphQL query. For example, a basic GraphQL query like this one:

query getMe {
  me
}

Is valid when the type provided for the query starting type has a field named “me”. Similarly

mutation setName {
  setName(name: "Zuck") {
    newName
  }
}

Is valid when the type provided for the mutation starting type is not null, and has a field named “setName” with a string argument named “name”.

4Introspection

A GraphQL server supports introspection over its schema. This schema is queried using GraphQL itself, creating a powerful platform for tool‐building.

Take an example query for a trivial app. In this case there is a User type with three fields: id, user, and birthday.

For example, given a server with the following type definition:

type User {
  id: String
  name: String
  birthday: Date
}

The query

{
  __type(name: "User") {
    name
    fields {
      name
      type { name }
    }
  }
}

would return

{
  "__type": {
    "name" : "User",
    "fields": [
      { "name": "id", "type": { "name": "String" } },
      { "name": "name", "type": { "name": "String" } },
      { "name": "birthday", "type": { "name": "Date" } },
    ]
  }
}

4.1General Principles

4.1.1Naming conventions

Types and fields required by the GraphQL introspection system that are used in the same context as user‐defined type and fields are prefixed with two underscores. This in order to avoid naming collisions with user‐defined GraphQL types. Conversely, GraphQL type system authors must not define any types, fields, arguments, or any other type system artifact with two leading underscores.

4.1.2Documentation

All types in the introspection system provide a description field of type String to allow type designers to publish documentation in addition to capabilities. A GraphQL server may return the description field using Markdown syntax. Therefore it is recommended that any tool that displays description use a Markdown renderer.

4.1.3Deprecation

To support the management of backwards compatibility, GraphQL fields and enum values can indicate whether or not they are deprecated (isDeprecated: Boolean) and a description of why it is deprecated (deprecationReason: String).

Tools built using GraphQL introspection should respect deprecation by discouraging deprecated use through information hiding or developer‐facing warnings.

4.1.4Type Name Introspection

GraphQL supports type name introspection within at any point in a query by the meta field __typename: String! when querying against any Object, Interface, or Union. It returns the name of the object type currently being queryied.

This is most often used when querying against Interface or Union types to identify which actual type of the possible types has been returned.

This field is implicit and does not appear in the fields list in any defined type.

4.2Schema Introspection

The schema introspection system is accessible from the meta‐fields __schema and __type which are accessible from the type of the root of a query operation.

__schema : __Schema!
__type(name: String) : __Type

These fields are implicit and do not appear in the fields list in the root type of the query operation.

The schema of the GraphQL schema introspection system:

type __Schema {
  types: [__Type!]!
  queryType: __Type!
  mutationType: __Type
  directives: [__Directive!]!
}

type __Type {
  kind: __TypeKind!
  name: String
  description: String

  # OBJECT and INTERFACE only
  fields(includeDeprecated: Boolean = false): [__Field!]

  # OBJECT only
  interfaces: [__Type!]

  # INTERFACE and UNION only
  possibleTypes: [__Type!]

  # ENUM only
  enumValues(includeDeprecated: Boolean = false): [__EnumValue!]

  # INPUT_OBJECT only
  inputFields: [__InputValue!]

  # NON_NULL and LIST only
  ofType: __Type
}

type __Field {
  name: String!
  description: String
  args: [__InputValue!]!
  type: __Type!
  isDeprecated: Boolean!
  deprecationReason: String
}

type __InputValue {
  name: String!
  description: String
  type: __Type!
  defaultValue: String
}

type __EnumValue {
  name: String!
  description: String
  isDeprecated: Boolean!
  deprecationReason: String
}

enum __TypeKind {
  SCALAR
  OBJECT
  INTERFACE
  UNION
  ENUM
  INPUT_OBJECT
  LIST
  NON_NULL
}

type __Directive {
  name: String!
  description: String
  type: __Type
  onOperation: Boolean!
  onFragment: Boolean!
  onField: Boolean!
}

4.2.1The "__Type" Type

__Type is at the core of the type introspection system. It represents scalars, interfaces, object types, unions, enums in the system.

__Type also represents type modifiers, which are used to modify a type that it refers to (ofType: __Type). This is how we represent lists, non‐nullable types, and the combinations thereof.

4.2.2Type Kinds

There are several different kinds of type. In each kind, different fields are actually valid. These kinds are listed in the __TypeKind enumeration.

4.2.2.1Scalar

Represents scalar types such as Int, String, and Boolean. Scalars cannot have fields.

A GraphQL type designer should describe the data format and scalar coercion rules in the description field of any scalar.

Fields

  • kind must return __TypeKind.SCALAR.
  • name must return a String.
  • description may return a String or null.
  • All other fields must return null.
4.2.2.2Object

Object types represent concrete instantiations of sets of fields. The introspection types (e.g. __Type, __Field, etc) are examples of objects.

Fields

  • kind must return __TypeKind.OBJECT.
  • name must return a String.
  • description may return a String or null.
  • fields: The set of fields query‐able on this type.
    • Accepts the argument includeDeprecated which defaults to false. If true, deprecated fields are also returned.
  • interfaces: The set of interfaces that an object implements.
  • All other fields must return null.
4.2.2.3Union

Unions are an abstract types where no common fields are declared. The possible types of a union are explicitly listed out in possibleTypes. Types can be made parts of unions without modification of that type.

Fields

  • kind must return __TypeKind.UNION.
  • name must return a String.
  • description may return a String or null.
  • possibleTypes returns the list of types that can be represented within this union. They must be object types.
  • All other fields must return null.
4.2.2.4Interface

Interfaces is an abstract type where there are common fields declared. Any type that implements an interface must define all the fields with names and types exactly matching. The implementations of this interface are explicitly listed out in possibleTypes.

Fields

  • kind must return __TypeKind.INTERFACE.
  • name must return a String.
  • description may return a String or null.
  • fields: The set of fields required by this interface.
    • Accepts the argument includeDeprecated which defaults to false. If true, deprecated fields are also returned.
  • possibleTypes returns the list of types that can be represented within this union. They must be object types.
  • All other fields must return null.
4.2.2.5Enum

Enums are special scalars that can only have a defined set of values.

Fields

  • kind must return __TypeKind.ENUM.
  • name must return a String.
  • description may return a String or null.
  • enumValues: The list of EnumValue. There must be at least one and they must have unique names.
    • Accepts the argument includeDeprecated which defaults to false. If true, deprecated enum values are also returned.
  • All other fields must return null.
4.2.2.6Input Object

Input objects are composite types used as inputs into queries defined as a list of named input values.

For example the an input object Point could be defined as:

type Point {
  x: Int
  y: Int
}

Fields

  • kind must return __TypeKind.INPUT_OBJECT.
  • name must return a String.
  • description may return a String or null.
  • inputFields: a list of InputValue.
  • All other fields must return null.
4.2.2.7List

Lists represent sequences of values in GraphQL. A List type is a type modifier: it wraps another type instance in the ofType field, which defines the type of each item in the list.

Fields

  • kind must return __TypeKind.LIST.
  • ofType: Any type.
  • All other fields must return null.
4.2.2.8Non-null

GraphQL types are nullable. The value null is a valid response for field type.

A Non‐null type is a type modifier: it wraps another type instance in the ofType field. Non‐null types do not allow null as a response, and indicate required inputs for arguments and input object fields.

  • kind must return __TypeKind.NON_NULL.
  • ofType: Any type except Non‐null.
  • All other fields must return null.
4.2.2.9Combining List and Non-Null

List and Non‐Null can compose, representing more complex types.

If the modified type of a List is Non‐Null, then that List may not contain any null items.

If the modified type of a Non‐Null is List, then null is not accepted, however an empty list is accepted.

If the modified type of a List is a List, then each item in the first List is another List of the second List’s type.

A Non‐Null type cannot modify another Non‐Null type.

5Validation

GraphQL does not just verify if a request is syntatically correct.

Prior to execution, it can also verify that a request is valid within the context of a given GraphQL schema. Validation is primarily targeted at development‐time tooling. Any client‐side tooling should returns errors and not allow the formulation of queries known to violate the type system at a given point in time.

Total request validation on the server‐side during execution is optional. As schemas and systems change over time existing clients may end up emitting queries that are no longer valid given the current type system. Servers (as described in the Execution section of this spec) attempt to satisfy as much as the request as possible and continue to execute in the presence of type system errors rather than cease execution completely.

For this section of this schema, we will assume the following type system in order to demonstrate examples:


enum DogCommand { SIT, DOWN, HEEL }

type Dog : Pet {
  name: String!,
  nickname: String,
  barkVolume : Int,
  doesKnowCommand(dogCommand: DogCommand!) : Boolean!
  isHousetrained(atOtherHomes: Boolean): Boolean!
}

interface Sentient { name: String! }
interface Pet { name: String!, nickname: String }

type Alien : Sentient { name: String!, homePlanet: String }
type Human : Sentient { name: String! }

type Cat : Pet {
  name: String!,
  nickname: String,
  meowVolume: Int
}

union CatOrDog = Cat | Dog
union DogOrHuman = Dog | Human
union HumanOrAlien = Human | Alien

5.1Fields

5.1.1Field Selections on Objects, Interfaces, and Unions Types

Formal Specification

  • For each selection in the document.
  • Let fieldName be the target field of selection
  • fieldName must be defined on type in scope

Explanatory Text

The target field of a field selection must defined on the scoped type of the selection set. There are no limitations on alias names.

For example the following fragment would not pass validation:


fragment fieldNotDefined on Dog {
  meowVolume
}

fragment aliasedLyingFieldTargetNotDefined on Dog {
  barkVolume : kawVolume
}

For interfaces, direct field selection can only be done on fields. Fields of concrete implementors is not relevant to the validity of the given interface‐typed selection set.

For example, the following is valid:

fragment interfaceFieldSelection on Pet {
  name
}

and the following is invalid:

fragment definedOnImplementorsButNotInterface : Pet {
  nickname
}

Because fields are not declared on unions, direct field selection on union‐typed selection set. This is true even if concrete implementors of the union define the fieldName.

For example the following is invalid

fragment directFieldSelectionOnUnion : CatOrDog {
  directField
}

fragment definedOnImplementorsQueriedOnUnion : CatOrDog {
  name
}

5.1.2Field Selection Merging

Formal Specification

  • Let set be any selection set defined in the GraphQL document
  • Let setForKey be the set of selections with a given response key in set
  • All members of setForKey must:
    • Have identical target fields
    • Have identical sets of arguments name‐value pairs.
    • Have identical sets of directive name‐value pairs.

Explanatory Text

Selection names are de‐duplicated and merged for validation, but the target field, arguments, and directives must all be identical.

For human‐curated GraphQL, this rules seem a bit counterintuitive since it appears to be clear developer error. However in the presence of nested fragments or machine‐generated GraphQL, requiring unique selections is a burdensome limitation on tool authors.

The following selections correctly merge:

fragment mergeIdenticalFields on Dog {
  name
  name
}

fragment mergeIdenticalAliasesAndFields on Dog {
  otherName : name
  otherName : name
}

The following is not able to merge:


fragment conflictingBecauseAlias on Dog {
  name : nickname
  name
}

Identical field arguments are also merged if they have identical arguments. Both values and variables can be correctly merged.

For example the following correctly merge:


fragment mergeIdenticalFieldsWithIdenticalArgs on Dog {
  doesKnowCommand(dogCommand: SIT)
  doesKnowCommand(dogCommand: SIT)
}

fragment mergeIdenticalFieldsWithIdenticalValues on Dog {
  doesKnowCommand(dogCommand: $dogCommand)
  doesKnowCommand(dogCommand: $dogCommand)
}

The following do not correctly merge:


fragment conflictingArgsOnValues on Dog {
  doesKnowCommand(dogCommand: SIT)
  doesKnowCommand(dogCommand: HEEL)
}

fragment conflictingArgsValueAndVar on Dog {
  doesKnowCommand(dogCommand: SIT)
  doesKnowCommand(dogCommand: $dogCommand)
}

fragment conflictingArgsWithVars on Dog {
  doesKnowCommand(dogCommand: $varOne)
  doesKnowCommand(dogCommand: $varTwo)
}

The same logic applies to directives. The set of directives on each selection with the same response key in a given scope must be identical.

The following is valid:

fragment mergeSameFieldsWithSameDirectives on Dog {
  name @if:true
  name @if:true
}

and the following is invalid:


fragment conflictingDirectiveArgs on Dog {
  name @if: true
  name @unless: false
}

5.1.3Leaf Field Selections

Formal Specification

  • For each selection in the document
  • Let selectionType be the result type of selection
  • If selectionType is a scalar:
    • The subselection set of that selection must be empty
  • If selectionType is an interface, union, or object
    • The subselection set of that selection must NOT BE empty

Explanatory Text

Field selections on scalars are never allowed: scalars are the leaf nodes of any GraphQL query.

The following is valid.

fragment scalarSelection: Dog {
  barkVolume
}

The following is invalid.

fragment scalarSelectionsNotAllowedOnBoolean : Dog {
  barkVolume { sinceWhen }
}

Conversely the leaf field selections of GraphQL queries must be scalars. Leaf selections on objects, interfaces, and unions without subfields are disallowed.

Let’s assume the following query root type of the schema:

type QueryRoot {
  human: Human
  pet: Pet
  catOrDog: CatOrDog
}

The following examples are invalid


query directQueryOnObjectWithoutSubFields
{
  human
}

query directQueryOnInterfaceWithoutSubFields
{
  pet
}

query directQueryOnUnionWithoutSubFields
{
  catOrDog
}

5.2Arguments

5.2.1Argument Names

Formal Specification

  • For each selection in the document
  • Let arguments be the set of argument provided to the selection
  • Let targetField be the target field of a given selection
  • Let argumentDefinitions be the set of argument definitions of targetField
  • Each argumentName in arguments must have a corresponding argument defintion in the targetField with the same name

Explanatory Text

Field selections may take arguments. Each field selection corresponds to a field definition on the enclosing type, which specifies a set of possible arguments. Every argument provided to the selection must be defined in the set of possible arguments.

For example the following are valid:

fragment argOnRequiredArg on Dog {
  doesKnowCommand(dogCommand: SIT)
}

fragment argOnOptional on Dog {
  isHousetrained(atOtherHomes: true)
}

and the following is invalid since command is not defined on DogCommand:


fragment invalidArgName on Dog {
  doesKnowCommand(command: CLEAN_UP_HOUSE)
}

In order to explore more complicated argument examples, let’s add the following to our type system:

type Arguments {
  multipleReqs(x: Int!, y: Int!)
  booleanArgField(booleanArg: Boolean)
  floatArgField(floatArg: Float)
  intArgField(intArg: Int)
  nonNullBooleanArgField(nonNullBooleanArg: Boolean!)
}

Order does not matter in arguments. Therefore both the following example are valid.

fragment multipleArgs on Arguments {
  multipleReqs(x: 1, y: 2)
}

fragment multipleArgsReverseOrder on Arguments {
  multipleReqs(y: 1, x: 2)
}

5.2.2Argument Values Type Correctness

5.2.2.1Compatible Values

Formal Specification

  • For each selection in the document
  • Let arguments be the set of argument provided to the selection
  • Let targetField be the target field of a given selection
  • Let argumentDefinitions be the set of argument definitions of targetField
  • For each literalArgument of all arguements with literal for values.
    • The type of literalArgument must equal the type of the argument defintion OR
    • The type of literalArgument must be coercable to type of the argument definition

Explanatory Text

Argument literal values must be compatible with the type defined on the type that literal is being passed to.

This means either

  • the types must match equally or
  • the types must be coercable.

For example, an Int can be coerced into a Float.

fragment goodBooleanArg on Arguments {
  booleanArgField(booleanArg: true)
}

fragment coercedIntIntoFloatArg on Arguments {
  floatArgField(floatArg: 1)
}

An uncoerceable conversion, is string to int. Therefore, the following example is invalid.

fragment stringIntoInt on Arguments {
  intArgField(intArg: "3")
}
5.2.2.2Argument Optionality
  • For each selection in the document
  • Let arguments be the set of argument provided to the selection
  • Let targetField be the target field of a given selection
  • Let argumentDefinitions be the set of argument definitions of targetField
  • For each definition in argumentDefinition, if the type of definition is non‐null a value must be provided.

Explanatory Text

Field arguments can be required. Field arguments are required if the type of the argument is non‐null. If it is not non‐null, the argument is optional. Optional arguments must have default values.

For example the following are valid:

fragment goodBooleanArg on Arguments {
  booleanArgField(booleanArg: true)
}

fragment goodNonNullArg on Arguments {
  nonNullBooleanArgField(nonNullBooleanArg: true)
}

On a field with a a nullable arg, that argument can be omitted.

Therefore the following query is valid:


fragment goodBooleanArgDefault on Arguments {
  booleanArgField
}

but this is not valid on a non‐null argument.

fragment missingRequiredArg on Arguments {
  notNullBooleanArgField
}

5.3Fragments

5.3.1Fragment Declarations

5.3.1.1Fragment Spread Type Existence

Formal Specification

  • For each named spread namedSpread in the document
  • Let fragment be the target of namedSpread
  • The target type of fragment must be defined in the schema

Explanatory Text

Fragments must be specified on types that exist in the schema. This applies for both named and inline fragments. If they are not defined in the schema, the query does not validate.

For example the following fragments are valid:


fragment CorrectType on Dog {
  name
}

fragment InlineFragment on Dog {
  ... on Dog {
    name
  }
}

and the following do not validate:


fragment NotOnExistingType on NotInSchema {
  name
}

fragment InlineNotExistingType on Dog {
  ... on NotInSchema { name }
}
5.3.1.2Fragments On Composite Types

Formal Specification

  • For each fragment defined in the document.
  • The target type of fragment must be have kind UNION, INTERFACE, or OBJECT.

Explanatory Text

Fragments can only be declared on unions, interfaces, and objects. They are invalid on scalars. They can only be applied on non‐leaf fields. This rule applies to both inline and named fragments.

The following fragment declarations are valid:

fragment fragOnObject on Dog { name }
fragment fragOnInterface on Pet { name }
fragment fragOnUnion on CatOrDog { ... on Dog { name } }

and the following are invalid:

fragment fragOnScalar on Int { something }
fragment inlineFragOnScalar on Dog { ... on Boolean { somethingElse } }
5.3.1.3Fragments Must Be Used

Formal Specification

  • For each fragment defined in the document.
  • fragment must be be the target of at least one spread in the document

Explanatory Text

Defined fragments must be used within a query document.

For example the following is an invalid query document:

fragment nameFragment on Dog { // unused
  name
}
{ dog { name } }

5.3.2Fragment Spreads

Field selection is also determined by spreading fragments into one another. The selection set of the target fragment is unioned with the selection set at the level at which the target fragment is referenced.

5.3.2.1Fragment spread target defined

Formal Specification

  • For every namedSpread in the document.
  • Let fragment be the target of namedSpread
  • fragment must be defined in the document

Explanatory Text

Named fragment spreads must refer to fragments defined within the document. If the target of a spread is not defined, this is an error:

fragment nameFragment on Dog { name }
{ dog { ...undefinedFragment} }
5.3.2.2Fragment spreads must not form cycles

Formal Specification

  • For each fragmentDefinition in the document
  • Let visited be the empty set.
  • DetectCycles(fragmentDefinition, visited)

DetectCycles(fragmentDefinition, visited) :

  • Let spreads be all fragment spread descendents of fragmentDefinition
  • For each spread in spreads
    • visited must not contain spread
    • Let nextVisited be the set including spread and members of visited
    • Let nextFragmentDefinition be the target of spread
    • DetectCycles(nextFragmentDefinition, nextVisited)

Explanatory Text

The graph of fragment spreads must not form any cycles including spreading itself. Otherwise an operation could infinitely spread or infinitely execute on cycles in the underlying data.

This invalidates fragments that would result in an infinite spread:

{
  dog {
    ...nameFragment
  }
}

fragment nameFragment on Dog {
  name
  ...barkVolumeFragment
}

fragment barkVolumeFragment on Dog {
  barkVolume
  ...nameFragment
}

If the above fragments were inlined, this would result in the infinitely large:

{
  dog {
    name, barkVolume, name, barkVolume, name, barkVolume, name, # etc...
  }
}

This also invalidates fragments that would result in an infinite recursion when executed against cyclic data:

{
  dog {
    ...dogFragment
  }
}

fragment dogFragment on Dog {
  name
  owner {
    ...ownerFragment
  }
}

fragment ownerFragment on Dog {
  name
  pets {
    ...dogFragment
  }
}
5.3.2.3Fragment spread is possible

Formal Specification

  • For each spread (named or inline) in defined in the document.
  • Let fragment be the target of spread
  • Let fragmentType be the type condition of fragment
  • Let parentType be the type of the selection set containing spread
  • Let applicableTypes be the intersection of GetPossibleTypes(fragmentType) and GetPossibleTypes(parentType)
  • applicableTypes must not be empty.
GetPossibleTypes(type)
  1. If type is an object type, return a set containing type
  2. If type is an interface type, return the set of types implementing type
  3. If type is a union type, return the set of possible types of type

Explanatory Text

Fragments are declared on a type and will only apply when the runtime object type matches the type condition. They also are spread within the context of a parent type. A fragment spread is only valid if its type condition could ever apply within the parent type.

and the following valid fragments:

5.3.2.3.1Object Spreads In Object Scope

In the scope of a object type, the only valid object type fragment spread is one that applies to the same type that is in scope.

For example

fragment dogFragment on Dog { ... on Dog { barkVolume } }

and the following is invalid

fragment catInDogFragmentInvalid on Dog { ... on Cat { meowVolume } }
5.3.2.3.2Abstract Spreads in Object Scope

In scope of an object type, unions or interface spreads can be used if the object type implements the interface or is a member of the union.

For example

fragment petNameFragment on Pet { name }
fragment interfaceWithinObjectFragment on Dog { ...petNameFragment }

is valid because Dog implements Pet.

Likewise

fragment CatOrDogNameFragment on CatOrDog { ... on Cat { meowVolume } }
fragment unionWithObjectFragment on Dog { ...CatOrDogFragment }

is valid because Dog is a member of the CatOrDog union. It is worth noting that if one inspected the contents of the CatOrDogNameFragment you could note that the no valid results would ever be returned. However we do not specify this as invalid because we only consider the fragment declaration, not its body.

5.3.2.3.3Object Spreads In Abstract Scope

Union or interface spreads can be used within the context of an object type fragment, but only if the object type is one of the possible types of the that interface or union.

For example, the following fragments are valid:

fragment petFragment on Pet { name, ... on Dog { barkVolume } }
fragment catOrDogFragment on CatOrDog { ... on Cat { meowVolume } }

petFragment is valid because Dog implements the interface Pet. catOrDogFragment is valid because Cat is a member of the CatOrDog union.

By contrast the following fragments are invalid:

fragment sentientFragment on Sentient { ... on Dog { barkVolume } }
fragment humanOrAlienFragment on HumanOrAlien { ... on Cat { meowVolume } }

Dog does not implement the interface Sentient and therefore sentientFragment can never return meaningful results. Therefore the fragment is invalid. Likewise Cat is not a member of the union HumanOrAlien, and it can also never return meaningful results, making it invalid.

5.3.2.3.4Abstract Spreads in Abstract Scope

Union or interfaces fragments can be used within eachother. As long as there exists at least one object type that exists in the intersection of the possible types of the scope and the spread, the spread is considered valid.

So for example

fragment unionWithInterface Pet { ...dogOrHumanFragment }
fragment dogOrHumanFragment on DogOrHuman { ... on Dog { barkVolume } }

is consider valid because Dog implements interface Pet and is a member of DogOrHuman.

However

fragment nonIntersectingInterfaces on Pet { ...sentientFragment }
fragment sentientFragment on Sentient { name }

is not valid because there exists no type that implements both Pet and Sentient.

5.4Directives

5.4.1Directives Are Defined

Formal Specification

  • For every directiveUse in a document.
  • The name of that directive must be defined by the type system of the GraphQL server.

Explanatory Text

GraphQL servers define what directives they support. For each usage of a directive, the directive must be available on that server.

5.4.2Directive Arguments Are Of Correct Type

Formal Specification

  • For every directiveUse in a document.
  • Let directiveType be the input type of the corresponding directive defined on the server.
  • If directiveType is not defined:
    • The directive is meant to be used only as flag, and no argument should be provided.
  • If directiveType is defined and non‐null:
    • directiveUse must have an argument
  • Let argumentType be the type of argument supplied to directiveUse
  • argumentType and directiveType must be the same or argumentType must be coercable to directiveType

Explanatory Text

Directive arguments follow similar rules to arguments on fields. Much like field arguments, arguments to directives must be of the same type or coercable to input type of the directive type.

Directives arguments differ from field arguments insofar as they can be used without a provided argument. If the type of directive is not non‐null, the directive can be optionally used without an argument. If the type of a directive is not defined, it is a flag directive: it cannot have an argument, If a value is provided to a flag directive, this is a validation error.

5.5Operations

5.5.1Variables

5.5.1.1Variable Default Values Are Correctly Typed

Formal Specification

  • For every operation in a document
  • For every variable on each operation
    • Let variableType be the type of variable
    • If variableType is non‐null it cannot have a default value
    • If variable has a default value it must be of the same types or able to be coerced to variableType

Explanatory Text

Variable defined by operations are allowed to define default values if the type of that variable not non‐null.

For example the following query will pass validation.

  query HouseTrainedQuery($atOtherHomes: Boolean = true) {
    dog { isHousetrained(atOtherHomes: $atOtherHomes) }
  }

However if the variable is defined as non‐null, default values are unreachable. Therefore queries such as the following fail validation

  query HouseTrainedQuery($atOtherHomes: Boolean! = true) {
    dog { isHousetrained(atOtherHomes: $atOtherHomes) }
  }

Default values must be compatible with the types of variables. Types much match or they must be coercable to the type.

Non‐matching types fail, such as in the following example:

  query HouseTrainedQuery($atOtherHomes: Boolean = "true") {
    dog { isHousetrained(atOtherHomes: $atOtherHomes) }
  }

However if a type is coerceable the query will pass validation.

For example:

  query IntToFloatQuery($floatVar: Float = 1) {
    arguments {
      floatArgField(floatArg: $floatVar)
    }
  }
5.5.1.2Variables Are Input Types

Formal Specification

  • For every operation in a document
  • For every variable on each operation
    • Let variableType be the type of variable
    • variableType must of kind SCALAR, ENUM or INPUT_OBJECT

Explanatory Text

Variables can only be scalars, enums, input objects, or lists and non‐null variants of those types. These are known as input types. Object, unions, and interfaces cannot be used as inputs.

The following queries are valid:

  query TakesBoolean($atOtherHomes: Boolean) { /* ... */ }
  query TakesComplexInput($complexInput: ComplexInput) { /* ... */ }
  query TakesListOfBooleanBang($booleans: [Boolean!]) { /* ... */ }

The following queries are invalid:

  query TakesCat($cat: Cat) { /* ... */ }
  query TakesDogBang($dog: Dog!) { /* ... */ }
  query TakesListOfPet($pets: [Pet]) { /* ... */ }
  query TakesCatOrDog($catOrDog: CatOrDog) { /* ... */ }
5.5.1.3All Variable Uses Defined

Formal Specification

  • For each operation in a document
    • For each variableUsage in scope, variable must be operation’s variable list.
    • Let fragments be every fragment reference by that operation transitively
    • For each fragment in fragments
      • For each variableUsage in scope of fragment, variable must be operation‘s variable list.

Explanatory Text

Variables are scoped on a per‐operation basis. That means that any variable used within the context of a operation must be defined at the top level of that operation

For example:

query VariableIsDefined($atOtherHomes: Boolean) {
  dog { isHousetrained(atOtherHomes: $booleanArg)
}

is valid. $atOtherHomes is defined by the operation.

By constract the following query is invalid:

query VariableIsNotDefined {
  dog { isHousetrained(atOtherHomes: $atOtherHomes)
}

$atOtherHomes is not defined by the operation.

Fragments complicate this rule. Any fragment transitively included by an operation has access to the variables defined by that operation. Fragments can appear within multiple operations and therefore variable usages must correspond to variable definitions in all of those operations.

For example the following is valid:

query VariableIsDefinedUsedInSingleFragment($atOtherHomes: Boolean) {
  dog { ...isHousetrainedFragment }
}

fragment isHousetrainedFragment on Dog {
  isHousetrained(atOtherHomes: $atOtherHomes}
}

since isHousetrainedFragment is used within the context of the operation VariableIsDefinedUsedInSingleFragment and the variable is defined by that operation.

On the contrary is a fragment is included within an operation that does not define a referenced variable, this is a validation error.

query VariableIsNotDefinedUsedInSingleFragment {
  dog { ...isHousetrainedFragment }
}

fragment isHousetrainedFragment on Dog {
  isHousetrained(atOtherHomes: $atOtherHomes}
}

This applies transitively as well, so the following also fails:

query VariableIsNotDefinedUsedInNestedFragment {
  dog { ...outerHousetrainedFragment }
}

fragment outerHousetrainedFragment on Dog {
  ...isHousetrainedFragment
}

fragment isHousetrainedFragment on Dog {
  isHousetrained(atOtherHomes: $atOtherHomes}
}

Variables must be defined in all operations in which a fragment is used.

query HousetrainedQueryOne($atOtherHomes: Boolean) {
  dog { ...isHousetrainedFragment }
}

query HousetrainedQueryTwo($atOtherHomes: Boolean) {
  dog { ...isHousetrainedFragment }
}

fragment isHousetrainedFragment on Dog {
  isHousetrained(atOtherHomes: $atOtherHomes}
}

However the following does not validate:


query HousetrainedQueryOne($atOtherHomes: Boolean) {
  dog { ...isHousetrainedFragment }
}

query HousetrainedQueryTwoNotDefined {
  dog { ...isHousetrainedFragment }
}

fragment isHousetrainedFragment on Dog {
  isHousetrained(atOtherHomes: $atOtherHomes}
}

This is because HousetrainedQueryTwoNotDefined does not define a variable $atOtherHomes but that variable is used by isHousetrainedFragment which is included in that operation.

5.5.1.4All Variables Used

Formal Specification

  • For every operation in the document.
  • Let variables be the variables defined by that operation
  • Each variable in variables must be used at least once in either the operation scope itself or any fragment transitively referenced by that operation.

Explanatory Text

All variables defined by an operation must be used in that operation or a fragment transitively included by that operation. Unused variables cause a validation error.

For example the following is invalid:

query VariableUnused($atOtherHomes: Boolean) {
  dog { isHousetrained }
}

because $atOtherHomes in not referenced.

These rules apply to transitive fragment spreads as well:

query VariableUsedInFragment($atOtherHomes: Boolean) {
  dog { ...isHousetrainedFragment }
}

fragment isHousetrainedFragment on Dog {
  isHousetrained(atOtherHomes: $atOtherHomes)
}

The above is valid since $atOtherHomes is used in isHousetrainedFragment which is included by VariableUsedInFragment.

If that fragment did not have a reference to $atOtherHomes it would be not valid:

query VariableNotUsedWithinFragment($atOtherHomes: Boolean) {
  ...isHousetrainedWithoutVariableFragment
}

fragment isHousetrainedWithoutVariableFragment on Dog {
  isHousetrained
}

All operations in a document must use all of their variables.

As a result, the following document does not validate.


query QueryWithUsedVar($atOtherHomes: Boolean) {
  dog { ...isHousetrainedFragment }
}

query QueryWithExtraVar($atOtherHomes: Boolean, $extra: Int) {
  dog { ...isHousetrainedFragment }
}

fragment isHousetrainedFragment on Dog {
  isHousetrained(atOtherHomes: $atOtherHomes)
}

This document is not valid because QueryWithExtraVar defines an extraneous variable.

5.5.1.5All Variable Usages are Allowed

Formal Specification

  • For each operation in document
  • Let variableUsages be all usages transitively included in the operation
  • For each variableUsage in variableUsages
    • Let variableType be the type of variable definition in the operation
    • Let argumentType be the type of the argument the variable is passed to.
    • Let hasDefault be true if the variable definition defines a default.
    • AreTypesCompatible(argumentType, variableType, hasDefault) must be true
  • AreTypesCompatible(argumentType, variableType, hasDefault):
    • If hasDefault is true, treat the variableType as non‐null.
    • If inner type of argumentType and variableType be different, return false
    • If argumentType and variableType have different list dimensions, return false
    • If any list level of variableType is not non‐null, and the corresponding level in argument is non‐null, the types are not compatible.

Explanatory Text

Variable usages must be compatible with the arguments they are passed to.

Validation failures occur when variables are used in the context of types that are complete mismatches, or if a nullable type in a variable is passed to a not‐null argument type.

Types must match:

Query IntCannotGoIntoBoolean($intArg: Int) {
  arguments { booleanArgField(booleanArg: $intArg) }
}

$intArg typed as Int cannot be used as a argument to booleanArg, typed as Boolean.

List cardinality must also be the same. For example, lists cannot be passed into singular values.

Query BooleanListCannotGoIntoBoolean($booleanListArg: [Boolean]) {
  arguments { booleanArgField(booleanArg: $booleanListArg) }
}

Nullability must also be respected. In general a nullable variable cannot be passed to a non‐null argument.

Query BooleanArgQuery($booleanArg: Boolean) {
  arguments { nonNullBooleanArgField(nonNullBooleanArg: $booleanArg) }
}

A notable exception is when default arguments are provided. They are, in effect, treated as non‐nulls.

Query BooleanArgQueryWithDefault($booleanArg: Boolean = true) {
  arguments { nonNullBooleanArgField(nonNullBooleanArg: $booleanArg) }
}

For list types, the same rules around nullability apply to both outer types and inner types. A nullable list cannot be passed to a non‐null list, and a lists of nullable values cannot be passed to a list of non‐null values.


Query NonNullListToList($nonNullBooleanList: ![Boolean]) {
  arguments { booleanListArgField(booleanListArg: $nonNullBooleanList) }
}

However a nullable list could not be passed to a non‐null list.


Query ListToNonNullList($booleanList: [Boolean]) {
  arguments { nonNullBooleanListField(nonNullBooleanListArg: $booleanList) }
}

This would fail validation because a [T] cannot be passed to a [T]!.

Similarily a [T] cannot be passed to a [T!].

6Execution

This section describes how GraphQL generates a response from a request

6.1Evaluating requests

To evaluate a request, the executor will have a parsed Document (as defined in the “Query Language” part of this spec) and a selected operation name to run.

The executor should find the Operation in the Document with the given operation name. If no such operation exists, the executor should throw an error. If the operation is found, then the result of evaluating the request should be the result of evaluating the operation according to the “Evaluating operations” section.

6.2Evaluating operations

The type system, as described in the “Type System” part of the spec, must provide a “Query Root” and a “Mutation Root” object.

If the operation is a mutation, the result of the operation is the result of evaluating the mutation’s top level selection set on the “Mutation Root” object. This selection set should be evaluated serially.

If the operation is a query, the result of the operation is the result of evaluating the query’s top level selection set on the “Query Root” object.

6.3Evaluating selection sets

To evaluate a selection set, the executor needs to know the object on which it is evaluating the set and whether it is being evaluated serially.

If the selection set is being evaluated on the null object, then the result of evaluating the selection set is null.

Otherwise, the selection set is turned into a grouped field set; each entry in the grouped field set is a list of fields that share a responseKey.

The selection set is converted to a grouped field set by calling CollectFields, initializing visitedFragments to an empty list.

CollectFields(objectType, selectionSet, visitedFragments)
  1. Initialize groupedFields to an empty list of lists.
  2. For each selection in selectionSet;
    1. If selection is a Field:
      1. Let responseKey be the response key of selection.
      2. Let groupForResponseKey be the list in groupedFields for responseKey; if no such list exists, create it as an empty list.
      3. Append selection to the groupForResponseKey.
    2. If selection is a FragmentSpread:
      1. Let fragmentSpreadName be the name of selection.
      2. If fragmentSpreadName is in visitedFragments, continue with the next selection in selectionSet.
      3. Add fragmentSpreadName to visitedFragments.
      4. Let fragment be the Fragment in the current Document whose name is fragmentSpreadName.
      5. If no such fragment exists, continue with the next selection in selectionSet.
      6. Let fragmentType be the type condition on fragment.
      7. If doesFragmentTypeApply(objectType, fragmentType) is false, continue with the next selection in selectionSet.
      8. Let fragmentSelectionSet be the top‐level selection set of fragment.
      9. Let fragmentGroupedFields be the result of calling CollectFields(objectType, fragmentSelectionSet).
      10. For each fragmentGroup in fragmentGroupedFields:
        1. Let responseKey be the response key shared by all fields in fragmentGroup
        2. Let groupForResponseKey be the list in groupedFields for responseKey; if no such list exists, create it as an empty list.
        3. Append all items in fragmentGroup to groupForResponseKey.
    3. If selection is an inline fragment:
      1. Let fragmentType be the type condition on selection.
      2. If doesFragmentTypeApply(objectType, fragmentType) is false, continue with the next selection in selectionSet.
      3. Let fragmentSelectionSet be the top‐level selection set of selection.
      4. Let fragmentGroupedFields be the result of calling CollectFields(objectType, fragmentSelectionSet).
      5. For each fragmentGroup in fragmentGroupedFields:
        1. Let responseKey be the response key shared by all fields in fragmentGroup
        2. Let groupForResponseKey be the list in groupedFields for responseKey; if no such list exists, create it as an empty list.
        3. Append all items in fragmentGroup to groupForResponseKey.
  3. Return groupedFields.
doesFragmentTypeApply(objectType, fragmentType)
  1. If fragmentType is an Object Type, return true if objectType is fragmentType, otherwise return false.
  2. If fragmentType is an Interface Type, return true if objectType is an implementation of fragmentType, otherwise return false.
  3. If fragmentType is a Union, return true if objectType is a possible type of fragmentType, otherwise return false.

The result of evaluating the selection set is the result of evaluating the corresponding grouped field set. The corresponding grouped field set should be evaluated serially if the selection set is being evaluated serially, otherwise it should be evaluated normally.

6.4Evaluating a grouped field set

The result of evaluating a grouped field set will be an unordered map. There will be an entry in this map for every item in the grouped field set.

6.4.1Field entries

Each item in the grouped field set can potentially create an entry in the result map. That entry in the result map is the result is the result of calling GetFieldEntry on the corresponding item in the grouped field set. GetFieldEntry can return null, which indicates that there should be no entry in the result map for this item. Note that this is distinct from returning an entry with a string key and a null value, which indicates that an entry in the result should be added for that key, and its value should be null.

GetFieldEntry assumes the existence of two functions that are not defined in this section of the spec. It is expected that the type system provides these methods:

  • ResolveFieldOnObject, which takes an object type, a field, and an object, and returns the result of resolving that field on the object.
  • GetFieldTypeFromObjectType, which takes an object type and a field, and returns that field’s type on the object type, or null if the field is not valid on the object type.
GetFieldEntry(objectType, object, fields)
  1. Let firstField be the first entry in the ordered list fields. Note that fields is never empty, as the entry in the grouped field set would not exist if there were no fields.
  2. Let responseKey be the response key of firstField.
  3. Let fieldType be the result of calling GetFieldTypeFromObjectType(objectType, firstField).
  4. If fieldType is null, return null, indicating that no entry exists in the result map.
  5. Let resolvedObject be ResolveFieldOnObject(objectType, object, fieldEntry).
  6. If resolvedObject is null, return tuple(responseKey, null), indicating that an entry exists in the result map whose value is null.
  7. Let subSelectionSet be the result of calling MergeSelectionSets(fields).
  8. Let responseValue be the result of calling CompleteValue(fieldType, resolvedObject, subSelectionSet).
  9. Return tuple(responseKey, responseValue).
GetFieldTypeFromObjectType(objectType, firstField)
  1. Call the method provided by the type system for determining the field type on a given object type.
ResolveFieldOnObject(objectType, object, firstField)
  1. Call the method provided by the type system for determining the resolution of a field on a given object.
MergeSelectionSets(fields)
  1. Let selectionSet be an empty list.
  2. For each field in fields:
    1. Let fieldSelectionSet be the selection set of field.
    2. If fieldSelectionSet is null or empty, continue to the next field.
    3. Append all selections in fieldSelectionSet to selectionSet.
  3. Return selectionSet.
CompleteValue(fieldType, result, subSelectionSet)
  1. If the fieldType is a Non‐Null type:
    1. Let innerType be the inner type of fieldType.
    2. Let completedResult be the result of calling CompleteValue(innerType, result).
    3. If completedResult is null, throw a field error.
    4. Return completedResult.
  2. If result is null or a value similar to null such as undefined or NaN, return null.
  3. If fieldType is a List type:
    1. If result is not a collection of values, throw a field error.
    2. Let innerType be the inner type of fieldType.
    3. Return a list where each item is the result of calling CompleteValue(innerType, resultItem), where resultItem is each item in result.
  4. If fieldType is a Scalar or Enum type:
    1. Return the result of “coercing” result, ensuring it is a legal value of fieldType, otherwise null.
  5. If fieldType is an Object, Interface, or Union type:
    1. Return the result of evaluating subSelectionSet on fieldType normally.

6.4.2Normal evaluation

When evaluating a grouped field set without a serial execution order requirement, the executor can determine the entries in the result map in whatever order it chooses. Because the resolution of fields other than top‐level mutation fields is always side effect–free and idempotent, the execution order must not affect the result, and hence the server has the freedom to evaluate the field entries in whatever order it deems optimal.

For example, given the following grouped field set to be evaluated normally:

{
  birthday {
    month
  },
  address {
    street
  }
}

A valid GraphQL executor can resolve the four fields in whatever order it chose.

6.4.3Serial execution

Observe that based on the above sections, the only time an executor will run in serial execution order is on the top level selection set of a mutation operation and on its corresponding grouped field set.

When evaluating a grouped field set serially, the executor must consider each entry from the grouped field set in the order provided in the grouped field set. It must determine the corresponding entry in the result map for each item to completion before it continues on to the next item in the grouped field set:

For example, given the following selection set to be evaluated serially:

{
  changeBirthday(birthday: $newBirthday) {
    month
  },
  changeAddress(address: $newAddress) {
    street
  }
}

The executor must, in serial:

  • Run getFieldEntry for changeBirthday, which during CompleteValue will evaluate the { month } sub‐selection set normally.
  • Run getFieldEntry for changeAddress, which during CompleteValue will evaluate the { street } sub‐selection set normally.

As an illustrative example, let’s assume we have a mutation field changeTheNumber that returns an object containing one field, theNumber. If we execute the following selection set serially:

{
  first: changeTheNumber(newNumber: 1) {
    theNumber
  },
  second: changeTheNumber(newNumber: 3) {
    theNumber
  },
  third: changeTheNumber(newNumber: 2) {
    theNumber
  },
}

The executor will evaluate the following serially:

  • Resolve the changeTheNumber(newNumber: 1) field
  • Evaluate the { theNumber } sub‐selection set of first normally
  • Resolve the changeTheNumber(newNumber: 3) field
  • Evaluate the { theNumber } sub‐selection set of second normally
  • Resolve the changeTheNumber(newNumber: 2) field
  • Evaluate the { theNumber } sub‐selection set of third normally

A correct executor must generate the following result for that selection set:

{
  "first": {
    "theNumber": 1
  },
  "second": {
    "theNumber": 3
  },
  "third": {
    "theNumber": 2
  },
}

6.4.4Error handling

If an error occurs when resolving a field, it should be treated as though the field returned null, and an error must be added to the “errors” list in the response.

6.4.5Nullability

If the result of resolving a field is null (either because the function to resolve the field returned null or because an error occurred), and that field is marked as being non‐null in the type system, then the result of evaluating the entire field set that contains this field is now null.

If the field was null because of an error, then the error has already been logged, and the “errors” list in the response must not be affected.

If the field resolution function returned null, and the field was non‐null, then no error has been logged, so an appropriate error must be added to the “errors” list.

7Response

When a GraphQL server receives a request, it must return a well‐formed response. The server’s response describes the result of executing the requested operation if successful, and describes any errors encountered during the request.

A response may contain both a partial response as well as encountered errors in the case that an error occured on a field which was replaced with null.

7.1Serialization Format

GraphQL does not require a specific serialization format. However, clients should use a serialization format that supports the major primitives in the GraphQL response. In particular, the serialization format must support representations of the following four primitives:

A serialization format may support the following primitives, however, strings may be used as a substitute for those primitives.

7.1.1JSON Serialization

JSON is the preferred serialization format for GraphQL, though as noted above, GraphQL does not require a specific serialization format. For consistency and ease of notation, examples of the response are given in JSON throughout the spec. In particular, in our JSON examples, we will represent primitives using the following JSON concepts:

GraphQL Value JSON Value
Map Object
List Array
Null null
String String
Boolean true or false
Int Number
Float Number
Enum Value String

7.2Response Format

A response to a GraphQL operation must be a map.

If the operation included execution, the response map must contain the an entry with key “data”. The value of this entry is described in the “Data” section. If the operation failed before execution, due to a syntax error, missing information, or validation error, this entry must not be present.

If the operation encountered any errors, the response map must contain an entry with key “errors”. The value of this entry is described in the “Errors” section. If the operation completed without encountering any errors, this entry must not be present.

The response map may also contain an entry with key extensions. This entry, if set, must have a map as its value. This entry is reserved for implementors to extend the protocol however they see fit, and hence there are no additional restrictions on its contents.

To ensure future changes to the protocol do not break existing servers and clients, the top level response map must not contain any entries other than the three described above.

7.2.1Data

The data entry in the response will be the result of the execution of the requested operation. If the operation was a query, this output will be an object of the schema’s query root type; if the operation was a mutation, this output will be an object of the schema’s mutation root type.

If an error was encountered before execution begins, the data entry should not be present in the result.

If an error was encountered during the execution that prevented a valid response, the data entry in the response should be null.

7.2.2Errors

The errors entry in the response is a non‐empty list of errors, where each error is a map.

If no errors were encountered during the requested operation, the errors entry should not be present in the result.

Every error must contain an entry with the key message with a string description of the error intended for the developer as a guide to understand and correct the error.

If an error can be associated to a particular point in the requested GraphQL document, it should contain an entry with the key locations with a list of locations, where each location is a map with the keys line and column, both positive numbers starting from 1 which describe the beginning of an associated syntax element.

GraphQL servers may provide additional entries to error as they choose to produce more helpful or machine‐readable errors, however future versions of the spec may describe additional entries to errors.

If the data entry in the response is null or not present, the errors entry in the response must not be empty. It must contain at least one error. The errors it contains should indicate why no data was able to be returned.

If the data entry in the response is not null, the errors entry in the response may contain any errors that occurred during execution. If errors occurred during execution, it should contain those errors.

8Grammar

A GraphQL document is defined in a syntactic grammar where terminal symbols are tokens. Tokens are defined in a lexical grammar which matches patterns of source characters. The result of parsing a sequence of source UTF‐8 characters produces a GraphQL AST.

Symbols are defined (ex. Symbol :) as either one sequence of symbols or a list of possible sequences of symbols, either as a bulleted list or using the “one of” short hand.

A subscript suffix “Symbolopt ” is shorthand for two possible sequences, one including that symbol and one excluding it.

As an example:

Sentence
NounVerbAdverbopt

is shorthand for

Sentence
NounVerb
NounVerbAdverb

A subscript suffix “Symbollist ” is shorthand for a list of one or more of that symbol.

As an example:

Book
CoverPagelist Cover

is shorthand for

Book
CoverPage_listCover
Page_list
Page

A symbol definition subscript suffix parameter in braces “SymbolParam ” is shorthand for two symbol definitions, one appended with that parameter name, the other without. The same subscript suffix on a symbol is shorthand for that variant of the definition. If the parameter starts with “?”, that form of the symbol is used if in a symbol definition with the same parameter. Some possible sequences can be included or excluded conditionally when respectively prefixed with “[+Param]” and “[~Param]”.

As an example:

ExampleParam
A
BParam
CParam
ParamD
ParamE

is shorthand for

Example
A
B_param
C
E
Example_param
A
B_param
C_param
D

8.1Tokens

A GraphQL document is comprised of several kinds of source tokens defined here in a lexical grammar and used as terminal symbols in GraphQL’s syntactic grammar. This lexical grammar defines patterns of source characters by specifing character patterns in monospace or as /regular_expressions/. Non‐terminal patterns are defined as Italics.

The GraphQL document syntactic grammar is defined in terms of these lexical tokens:

Punctuator
! $ ( ) ... : = @ [ ] { | }
Name
/[_A-Za-z][_0-9A-Za-z]*/
Sign
-
NonZeroDigit
1 2 3 4 5 6 7 8 9
EscapedUnicode
u/[0-9A-Fa-f]{4}/
EscapedCharacter
" \ / b f n r t

8.1.1Ignored Source

Before every lexical token may be any amount of ignored source characters such as whitespace and comments. Whitespace, other than within strings, is not significant.

GraphQL treats comma , similarly to whitespace. This ensures that the absense or presence of a comma does not meaningfully alter the interpretted syntax of the document which is a common user‐error in other languages. It also allows for the stylistic use of trailing commas or line‐breaks as delimiters which are often desired for legibility and maintainability of source code. The use of commas and other whitespace is suggested when it improves legibility.

GraphQL ignores these character sequences:

WhiteSpace
Horizontal Tab (U+0009)
Vertical Tab (U+000B)
Form Feed (U+000C)
Space (U+0020)
No-break Space (U+00A0)
LineTerminator
New Line (U+000A)
Carriage Return (U+000D)
Line Separator (U+2028)
Paragraph Separator (U+2029)

8.2Syntax

A GraphQL document is defined in a syntactic grammar where terminal symbols are expressed as either an italicized token (ex. Document) or as monospaced short‐hand for a Punctuator (ex. :) or Name (ex. query).

8.2.1Document

A GraphQL document describes a complete file or request string. A document contains multiple definitions including an Operation.

Definition
TypeExtension
TypeDefinition
EnumDefinition

8.2.2Operations

An operation describes some type of request to GraphQL. The most common operation is a query, a read‐only request for data from GraphQL. A short‐hand syntax exists for a query operation.

OperationType
query mutation

8.2.3Fragments

Fragments allow for the reuse of common selections of fields, reducing duplicated text in the document. Inline fragments can be used directly inline a selection to apply a type condition when querying against an interface or union.

8.2.4Values

Fields may take values for arguments. A value may be any JSON‐style value, a variable or an Enum value.

BooleanValue
true
false
8.2.4.1Array Value
ArrayValueConst
[]
[ValueConstlist ]

Semantics

ArrayValue
[]
  1. Return a new empty list value.
ArrayValue
[Valuelist ]
  1. Let inputList be a new empty list value.
  2. For each Valuelist
    1. Let value be the result of evaluating Value.
    2. Append value to inputList.
  3. Return inputList
8.2.4.2Object Value
ObjectValueConst
{}
{ObjectFieldConstlist }

Semantics

ObjectValue
{}
  1. Return a new input object value with no fields.
ObjectValue
  1. Let inputObject be a new input object value with no fields.
  2. For each field in ObjectFieldlist
    1. Let name be Name in field.
    2. If inputObject contains a field named name throw Syntax Error.
    3. Let value be the result of evaluating Value in field.
    4. Add a field to inputObject of name name containing value value.
  3. Return inputObject

8.2.5Directives

Directives provide a way to describe runtime execution and type validation behavior in a GraphQL document.

8.2.6Types

GraphQL describes the schema of the data it provides using a type system. These types are referred to in the document when defining query variables.

Semantics

Type
  1. Let name be the string value of Name
  2. Let type be the type defined in the Schema named name
  3. type must not be null
  4. Return type
Type
  1. Let itemType be the result of evaluating Type
  2. Let type be a List type where itemType is the contained type.
  3. Return type
Type
  1. Let nullableType be the result of evaluating Type
  2. Let type be a Non‐Null type where nullableType is the contained type.
  3. Return type