Join us for GraphQL Summit, October 10-12 in San Diego. Use promo code ODYSSEY for $400 off your pass.
Launch GraphOS Studio
You're viewing documentation for an upcoming version of this software. Switch to the latest stable version.

Apollo AST

To generate client code, Apollo Kotlin parses both your GraphQL and each you write against it into an Abstract Syntax Tree (AST). An AST represents a GraphQL document in a type-safe, machine-readable format.

Apollo Kotlin's parser has its own module (apollo-ast), which you can use independently of apollo-runtime or apollo-api.

Features of apollo-ast include:


Add the apollo-ast dependency to your project:

dependencies {
// ...

Parsing a document

Use the parseAsGQLDocument method to parse a document from a File, a String, or an Okio BufferedSource.

val graphQLText = """
query HeroForEpisode(${"$"}ep: Episode) {
hero(episode: ${"$"}ep) {
friends {
val parseResult = graphQLText.parseAsGQLDocument()

This method returns a GQLResult<GQLDocument>, which contains the document and/or parsing issues, each of which can have a severity of either WARNING or ERROR. Because there can be warnings, it is possible to have both a valid document and issues at the same time.

To get the document and throw on errors, use getOrThrow():

val queryGqlDocument = parseResult.getOrThrow()

GQLDocument is the root of the AST. It contains a list of GQLDefinitions that together represent the GraphQL document.

All nodes in an AST are subclasses of GQLNode (all named with the GQL prefix). Each subclass exposes specific properties and methods relevant to the corresponding node type.

Example AST structure

In the HeroForEpisode example above, here's the structure of the AST returned by the parser:

└─GQLOperationDefinition query "HeroForEpisode"
├─GQLVariableDefinition "ep": "Episode"
└─GQLField "hero"
│ ├─GQLField "name"
│ ├─GQLField "friends"
│ │ └─GQLSelectionSet
│ │ └─GQLField "height"
│ └─GQLField "foobar"
└─GQLArgument "episode"
└─GQLVariableValue "ep"

Note that this structure and its node names closely follow the GraphQL specification.

Validating input

In addition to parsing, the apollo-ast library provides methods to perform higher-level validation of GraphQL documents.

To validate a parsed GQLDocument:

  • If the document represents a schema, call the validateAsSchema method.
  • If the document represents one or more operations, call the validateAsExecutable method.


validateAsSchema returns a GQLResult<Schema>. The following snippet parses and validates a short invalid that uses an undefined (@private):

val schemaText = """
type Query {
hero(episode: Episode): Character
enum Episode {
type Character @private {
name: String
height: Int @deprecated
friends: [Character]
val schemaGQLDocument = schemaText.parseAsGQLDocument().getOrThrow()
val schemaResult = schemaGQLDocument.validateAsSchema()
println( { + ": " + it.message })

When executed, this snippet prints [WARNING: Unknown directive 'private'].

Because this is a warning and not an error, you can still use the returned schemaResult.getOrThrow()


The validateAsExecutable method checks whether a document's defined s are valid against a particular provided Schema. You can obtain this Schema parameter by calling the above validateAsSchema on the GQLDocument that represents the :

val schema = schemaGQLDocument.validateAsSchema().getOrThrow()
val executableIssues = queryGqlDocument.validateAsExecutable(schema)
println( { + ": " + it.message })

If the queryGqlDocument queries a deprecated and misspells another, this snippet might print the following:

[WARNING: Use of deprecated field 'height', ERROR: Can't query 'frends' on type 'Character']

Outputting SDL

You can output a GQLDocument to standard GraphQL syntax with the toUtf8 extensions:

// Returns a string
// Output to a File

Transforming an AST

You can use the transform method of GQLDocument to modify an existing AST.

You pass transform a lambda that accepts a GQLNode and also returns instructions to manipulate the AST:

  • Continue: keep the node as-is and continue visiting the children
  • Delete: delete the node
  • Replace(GQLNode): replace the node with the given one

The transform method traverses the AST and executes the lambda for each node, then acts on the AST according to the lambda's return value.

Note that with Delete and Replace, the node's children are not visited automatically, so you should call transform recursively if that is needed.

For example, this snippet removes all s named restrictedField from s defined in queryGqlDocument and prints the result:

val transformedQuery = queryGqlDocument.transform{ node ->
if (node is GQLField && == "restrictedField") {
} else {
Kotlin native
JS Interoperability
Edit on GitHubEditForumsDiscord