graphql

graphql

Version 17.0.2
Published 3 days ago
6.52 MB
No dependencies
MIT license

Install

npm i graphql

yarn add graphql

pnpm add graphql

Overview

The root graphql package re-exports the public GraphQL.js API from its submodules and provides the high-level request pipeline helpers defined in this module.

You can import public exports from GraphQL.js modules through the root graphql package or through their module-specific entry point. For example, these two references resolve to the same parse function:

import { parse } from 'graphql';
import { parse } from 'graphql/language';

Use the root package when you want a single import surface, or use submodules such as graphql/language, graphql/type, graphql/execution, and graphql/utilities when you want module-focused imports. This module also defines root-only APIs, such as request pipeline helpers and version metadata, that do not belong to a narrower submodule.

Index

Variables

variable BREAK

const BREAK: {};

A value that can be returned from a visitor function to stop traversal.

variable BreakingChangeType

const BreakingChangeType: {
    readonly TYPE_REMOVED: 'TYPE_REMOVED';
    readonly TYPE_CHANGED_KIND: 'TYPE_CHANGED_KIND';
    readonly TYPE_REMOVED_FROM_UNION: 'TYPE_REMOVED_FROM_UNION';
    readonly VALUE_REMOVED_FROM_ENUM: 'VALUE_REMOVED_FROM_ENUM';
    readonly REQUIRED_INPUT_FIELD_ADDED: 'REQUIRED_INPUT_FIELD_ADDED';
    readonly IMPLEMENTED_INTERFACE_REMOVED: 'IMPLEMENTED_INTERFACE_REMOVED';
    readonly FIELD_REMOVED: 'FIELD_REMOVED';
    readonly FIELD_CHANGED_KIND: 'FIELD_CHANGED_KIND';
    readonly REQUIRED_ARG_ADDED: 'REQUIRED_ARG_ADDED';
    readonly ARG_REMOVED: 'ARG_REMOVED';
    readonly ARG_CHANGED_KIND: 'ARG_CHANGED_KIND';
    readonly DIRECTIVE_REMOVED: 'DIRECTIVE_REMOVED';
    readonly DIRECTIVE_ARG_REMOVED: 'DIRECTIVE_ARG_REMOVED';
    readonly REQUIRED_DIRECTIVE_ARG_ADDED: 'REQUIRED_DIRECTIVE_ARG_ADDED';
    readonly DIRECTIVE_REPEATABLE_REMOVED: 'DIRECTIVE_REPEATABLE_REMOVED';
    readonly DIRECTIVE_LOCATION_REMOVED: 'DIRECTIVE_LOCATION_REMOVED';
};

Categories of schema changes that may break existing operations.

variable DangerousChangeType

const DangerousChangeType: {
    readonly VALUE_ADDED_TO_ENUM: 'VALUE_ADDED_TO_ENUM';
    readonly TYPE_ADDED_TO_UNION: 'TYPE_ADDED_TO_UNION';
    readonly OPTIONAL_INPUT_FIELD_ADDED: 'OPTIONAL_INPUT_FIELD_ADDED';
    readonly OPTIONAL_ARG_ADDED: 'OPTIONAL_ARG_ADDED';
    readonly IMPLEMENTED_INTERFACE_ADDED: 'IMPLEMENTED_INTERFACE_ADDED';
    readonly ARG_DEFAULT_VALUE_CHANGE: 'ARG_DEFAULT_VALUE_CHANGE';
    readonly INPUT_FIELD_DEFAULT_VALUE_CHANGE: 'INPUT_FIELD_DEFAULT_VALUE_CHANGE';
};

Categories of schema changes that may be dangerous for existing operations.

variable DEFAULT_DEPRECATION_REASON

const DEFAULT_DEPRECATION_REASON: string;

Constant string used for default reason for a deprecation.

variable defaultFieldResolver

const defaultFieldResolver: GraphQLFieldResolver<unknown, unknown, any, unknown>;

If a resolve function is not given, then a default resolve behavior is used which takes the property of the source object of the same name as the field and returns it as the result, or if it's a function, returns the result of calling that function while passing along args and context value.

variable defaultHarness

const defaultHarness: GraphQLHarness;

Default harness backed by GraphQL.js parse, validate, execute, and subscribe implementations.

variable defaultTypeResolver

const defaultTypeResolver: GraphQLTypeResolver<unknown, unknown>;

If a resolveType function is not given, then a default resolve behavior is used which attempts two strategies:
First, See if the provided value has a __typename field defined, if so, use that value as name of the resolved type.
Otherwise, test each possible type for the abstract type by calling isTypeOf for the object being coerced, returning the first type that matches.

variable DirectiveLocation

const DirectiveLocation: {
    readonly QUERY: 'QUERY';
    readonly MUTATION: 'MUTATION';
    readonly SUBSCRIPTION: 'SUBSCRIPTION';
    readonly FIELD: 'FIELD';
    readonly FRAGMENT_DEFINITION: 'FRAGMENT_DEFINITION';
    readonly FRAGMENT_SPREAD: 'FRAGMENT_SPREAD';
    readonly INLINE_FRAGMENT: 'INLINE_FRAGMENT';
    readonly VARIABLE_DEFINITION: 'VARIABLE_DEFINITION';
    readonly FRAGMENT_VARIABLE_DEFINITION: 'FRAGMENT_VARIABLE_DEFINITION';
    readonly SCHEMA: 'SCHEMA';
    readonly SCALAR: 'SCALAR';
    readonly OBJECT: 'OBJECT';
    readonly FIELD_DEFINITION: 'FIELD_DEFINITION';
    readonly ARGUMENT_DEFINITION: 'ARGUMENT_DEFINITION';
    readonly INTERFACE: 'INTERFACE';
    readonly UNION: 'UNION';
    readonly ENUM: 'ENUM';
    readonly ENUM_VALUE: 'ENUM_VALUE';
    readonly INPUT_OBJECT: 'INPUT_OBJECT';
    readonly INPUT_FIELD_DEFINITION: 'INPUT_FIELD_DEFINITION';
    readonly DIRECTIVE_DEFINITION: 'DIRECTIVE_DEFINITION';
};

The set of allowed directive location values.

variable GRAPHQL_MAX_INT

const GRAPHQL_MAX_INT: number;

Maximum possible Int value as per GraphQL Spec (32-bit signed integer). n.b. This differs from JavaScript's numbers that are IEEE 754 doubles safe up-to 2^53 - 1

variable GRAPHQL_MIN_INT

const GRAPHQL_MIN_INT: number;

Minimum possible Int value as per GraphQL Spec (32-bit signed integer). n.b. This differs from JavaScript's numbers that are IEEE 754 doubles safe starting at -(2^53 - 1)

variable GraphQLBoolean

const GraphQLBoolean: GraphQLScalarType<boolean, boolean>;

The built-in Boolean scalar type.

variable GraphQLDeferDirective

const GraphQLDeferDirective: GraphQLDirective;

Experimental directive used to conditionally defer fragments.
This directive is exported for schemas that explicitly opt in to incremental delivery. It is not included in specifiedDirectives.

variable GraphQLDeprecatedDirective

const GraphQLDeprecatedDirective: GraphQLDirective;

Used to declare element of a GraphQL schema as deprecated.
The reason argument is non-null and defaults to DEFAULT_DEPRECATION_REASON.

variable GraphQLFloat

const GraphQLFloat: GraphQLScalarType<number, number>;

The built-in Float scalar type.

variable GraphQLID

const GraphQLID: GraphQLScalarType<string, string>;

The built-in ID scalar type.

variable GraphQLIncludeDirective

const GraphQLIncludeDirective: GraphQLDirective;

Used to conditionally include fields or fragments.

variable GraphQLInt

const GraphQLInt: GraphQLScalarType<number, number>;

The built-in Int scalar type.

variable GraphQLOneOfDirective

const GraphQLOneOfDirective: GraphQLDirective;

Used to indicate an Input Object is a OneOf Input Object.

variable GraphQLSkipDirective

const GraphQLSkipDirective: GraphQLDirective;

Used to conditionally skip (exclude) fields or fragments.

variable GraphQLSpecifiedByDirective

const GraphQLSpecifiedByDirective: GraphQLDirective;

Used to provide a URL for specifying the behavior of custom scalar definitions.

variable GraphQLStreamDirective

const GraphQLStreamDirective: GraphQLDirective;

Experimental directive used to conditionally stream list fields.
This directive is exported for schemas that explicitly opt in to incremental delivery. It is not included in specifiedDirectives.

variable GraphQLString

const GraphQLString: GraphQLScalarType<string, string>;

The built-in String scalar type.

variable introspectionTypes

const introspectionTypes: readonly GraphQLNamedType[];

All introspection types defined by the GraphQL specification.

variable OperationTypeNode

const OperationTypeNode: {
    readonly QUERY: 'query';
    readonly MUTATION: 'mutation';
    readonly SUBSCRIPTION: 'subscription';
};

The operation types supported by GraphQL executable definitions. Kinds

variable recommendedRules

const recommendedRules: readonly ValidationRule[];

Technically these aren't part of the spec but they are strongly encouraged validation rules.

variable SafeChangeType

const SafeChangeType: {
    readonly DESCRIPTION_CHANGED: 'DESCRIPTION_CHANGED';
    readonly TYPE_ADDED: 'TYPE_ADDED';
    readonly OPTIONAL_INPUT_FIELD_ADDED: 'OPTIONAL_INPUT_FIELD_ADDED';
    readonly OPTIONAL_ARG_ADDED: 'OPTIONAL_ARG_ADDED';
    readonly DIRECTIVE_ADDED: 'DIRECTIVE_ADDED';
    readonly FIELD_ADDED: 'FIELD_ADDED';
    readonly DIRECTIVE_REPEATABLE_ADDED: 'DIRECTIVE_REPEATABLE_ADDED';
    readonly DIRECTIVE_LOCATION_ADDED: 'DIRECTIVE_LOCATION_ADDED';
    readonly OPTIONAL_DIRECTIVE_ARG_ADDED: 'OPTIONAL_DIRECTIVE_ARG_ADDED';
    readonly FIELD_CHANGED_KIND_SAFE: 'FIELD_CHANGED_KIND_SAFE';
    readonly ARG_CHANGED_KIND_SAFE: 'ARG_CHANGED_KIND_SAFE';
    readonly ARG_DEFAULT_VALUE_ADDED: 'ARG_DEFAULT_VALUE_ADDED';
    readonly INPUT_FIELD_DEFAULT_VALUE_ADDED: 'INPUT_FIELD_DEFAULT_VALUE_ADDED';
};

Categories of schema changes that are considered safe for existing operations.

variable SchemaMetaFieldDef

const SchemaMetaFieldDef: GraphQLField<unknown, unknown, any>;

Note that these are GraphQLField and not GraphQLFieldConfig, so the format for args is different.

variable specifiedDirectives

const specifiedDirectives: readonly GraphQLDirective[];

Full list of stable directives specified by GraphQL.js.
Experimental @defer and @stream are exported separately and are not included in this list.

variable specifiedRules

const specifiedRules: readonly ValidationRule[];

This set includes all validation rules defined by the GraphQL spec.
The order of the rules in this list has been adjusted to lead to the most clear output when encountering multiple validation errors.

variable specifiedScalarTypes

const specifiedScalarTypes: readonly GraphQLScalarType<unknown, unknown>[];

All built-in scalar types defined by the GraphQL specification.

variable TokenKind

const TokenKind: {
    readonly SOF: '<SOF>';
    readonly EOF: '<EOF>';
    readonly BANG: '!';
    readonly DOLLAR: '$';
    readonly AMP: '&';
    readonly PAREN_L: '(';
    readonly PAREN_R: ')';
    readonly DOT: '.';
    readonly SPREAD: '...';
    readonly COLON: ':';
    readonly EQUALS: '=';
    readonly AT: '@';
    readonly BRACKET_L: '[';
    readonly BRACKET_R: ']';
    readonly BRACE_L: '{';
    readonly PIPE: '|';
    readonly BRACE_R: '}';
    readonly NAME: 'Name';
    readonly INT: 'Int';
    readonly FLOAT: 'Float';
    readonly STRING: 'String';
    readonly BLOCK_STRING: 'BlockString';
    readonly COMMENT: 'Comment';
};

An exported enum describing the different kinds of tokens that the lexer emits.

variable TypeKind

const TypeKind: {
    readonly SCALAR: 'SCALAR';
    readonly OBJECT: 'OBJECT';
    readonly INTERFACE: 'INTERFACE';
    readonly UNION: 'UNION';
    readonly ENUM: 'ENUM';
    readonly INPUT_OBJECT: 'INPUT_OBJECT';
    readonly LIST: 'LIST';
    readonly NON_NULL: 'NON_NULL';
};

The introspection enum describing the different kinds of GraphQL types. Introspection

variable TypeMetaFieldDef

const TypeMetaFieldDef: GraphQLField<unknown, unknown, any>;

The __type meta field definition used by introspection.

variable TypeNameMetaFieldDef

const TypeNameMetaFieldDef: GraphQLField<unknown, unknown, any>;

The __typename meta field definition used by execution and introspection.

variable version

const version: string;

A string containing the version of the GraphQL.js library

variable versionInfo

const versionInfo: Readonly<{
    major: number;
    minor: number;
    patch: number;
    preReleaseTag: string | null;
}>;

An object containing the components of the GraphQL.js version string

Functions

function assertAbstractType

assertAbstractType: (type: unknown) => GraphQLAbstractType;

Returns the value as a GraphQL abstract type, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQL abstract type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertAbstractType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Query {
    node: Node
  }
`);

const nodeType = assertAbstractType(schema.getType('Node'));

nodeType.toString(); // => 'Node'
assertAbstractType(schema.getType('User')); // throws an error

function assertArgument

assertArgument: (arg: unknown) => GraphQLArgument;

Returns the value as a GraphQLArgument, or throws if it is not one.

Parameter arg

Value to inspect.

Returns

The value typed as a GraphQLArgument.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertArgument } from 'graphql/type';

const schema = buildSchema('type Query { greeting(name: String): String }');
const arg = assertArgument(schema.getQueryType().getFields().greeting.args[0]);

arg.name; // => 'name'
assertArgument(schema.getQueryType()); // throws an error

function assertCompositeType

assertCompositeType: (type: unknown) => GraphQLCompositeType;

Returns the value as a GraphQL composite type, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQL composite type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertCompositeType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Query {
    node: Node
  }
`);

const userType = assertCompositeType(schema.getType('User'));

userType.toString(); // => 'User'
assertCompositeType(schema.getType('String')); // throws an error

function assertDirective

assertDirective: (directive: unknown) => GraphQLDirective;

Returns the value as a GraphQLDirective, or throws if it is not a directive.

Parameter directive

Value to inspect.

Returns

The value typed as a GraphQLDirective.

Example 1

import { DirectiveLocation } from 'graphql/language';
import { assertDirective, GraphQLDirective, GraphQLString } from 'graphql/type';

const upper = new GraphQLDirective({
  name: 'upper',
  locations: [DirectiveLocation.FIELD_DEFINITION],
});

assertDirective(upper); // => upper
assertDirective(GraphQLString); // throws an error

function assertEnumType

assertEnumType: (type: unknown) => GraphQLEnumType;

Returns the value as a GraphQLEnumType, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQLEnumType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertEnumType } from 'graphql/type';

const schema = buildSchema(`
  enum Episode {
    NEW_HOPE
    EMPIRE
  }

  type Query {
    favoriteEpisode: Episode
  }
`);

const episodeType = assertEnumType(schema.getType('Episode'));

episodeType.getValues().map((value) => value.name); // => ['NEW_HOPE', 'EMPIRE']
assertEnumType(schema.getType('Query')); // throws an error

function assertEnumValue

assertEnumValue: (value: unknown) => GraphQLEnumValue;

Returns the value as a GraphQLEnumValue, or throws if it is not one.

Parameter value

Value to inspect.

Returns

The value typed as a GraphQLEnumValue.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertEnumType, assertEnumValue } from 'graphql/type';

const schema = buildSchema(
  'enum Episode { NEW_HOPE } type Query { episode: Episode }',
);
const enumValue = assertEnumValue(
  assertEnumType(schema.getType('Episode')).getValues()[0],
);

enumValue.name; // => 'NEW_HOPE'
assertEnumValue(schema.getType('Episode')); // throws an error

function assertEnumValueName

assertEnumValueName: (name: string) => string;

Upholds the spec rules about naming enum values.

Parameter name

The GraphQL name to validate.

Returns

The validated GraphQL name.

Example 1

import { assertEnumValueName } from 'graphql/type';

assertEnumValueName('ACTIVE'); // => 'ACTIVE'
assertEnumValueName('true'); // throws an error

function assertField

assertField: (field: unknown) => GraphQLField;

Returns the value as a GraphQLField, or throws if it is not one.

Parameter field

Value to inspect.

Returns

The value typed as a GraphQLField.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertField } from 'graphql/type';

const schema = buildSchema('type Query { greeting: String }');
const field = assertField(schema.getQueryType().getFields().greeting);

field.name; // => 'greeting'
assertField(schema.getQueryType()); // throws an error

function assertInputField

assertInputField: (field: unknown) => GraphQLInputField;

Returns the value as a GraphQLInputField, or throws if it is not one.

Parameter field

Value to inspect.

Returns

The value typed as a GraphQLInputField.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInputField, assertInputObjectType } from 'graphql/type';

const schema = buildSchema(
  'input ReviewInput { stars: Int } type Query { ok: Boolean }',
);
const inputField = assertInputField(
  assertInputObjectType(schema.getType('ReviewInput')).getFields().stars,
);

inputField.name; // => 'stars'
assertInputField(schema.getQueryType()); // throws an error

function assertInputObjectType

assertInputObjectType: (type: unknown) => GraphQLInputObjectType;

Returns the value as a GraphQLInputObjectType, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQLInputObjectType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInputObjectType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type Review {
    stars: Int!
  }

  type Query {
    review(input: ReviewInput): Review
  }
`);

const inputType = assertInputObjectType(schema.getType('ReviewInput'));

Object.keys(inputType.getFields()); // => ['stars']
assertInputObjectType(schema.getType('Review')); // throws an error

function assertInputType

assertInputType: (type: unknown) => GraphQLInputType;

Returns the value as a GraphQL input type, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQL input type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInputType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type Review {
    stars: Int!
  }

  type Query {
    review(input: ReviewInput): Review
  }
`);

const inputType = assertInputType(schema.getType('ReviewInput'));

inputType.toString(); // => 'ReviewInput'
assertInputType(schema.getType('Review')); // throws an error

function assertInterfaceType

assertInterfaceType: (type: unknown) => GraphQLInterfaceType;

Returns the value as a GraphQLInterfaceType, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQLInterfaceType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInterfaceType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Query {
    node: Node
  }
`);

const nodeType = assertInterfaceType(schema.getType('Node'));

nodeType.name; // => 'Node'
assertInterfaceType(schema.getType('User')); // throws an error

function assertLeafType

assertLeafType: (type: unknown) => GraphQLLeafType;

Returns the value as a GraphQL leaf type, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQL leaf type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertLeafType } from 'graphql/type';

const schema = buildSchema(`
  enum Episode {
    NEW_HOPE
  }

  type Review {
    stars: Int!
  }

  type Query {
    episode: Episode
    review: Review
  }
`);

const episodeType = assertLeafType(schema.getType('Episode'));

episodeType.toString(); // => 'Episode'
assertLeafType(schema.getType('Review')); // throws an error

function assertListType

assertListType: (type: unknown) => GraphQLList<GraphQLType>;

Returns the value as a GraphQLList, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQLList.

Example 1

import { GraphQLList, GraphQLString, assertListType } from 'graphql/type';

const listType = assertListType(new GraphQLList(GraphQLString));

listType.ofType; // => GraphQLString
assertListType(GraphQLString); // throws an error

function assertName

assertName: (name: string) => string;

Upholds the spec rules about naming.

Parameter name

The GraphQL name to validate.

Returns

The validated GraphQL name.

Example 1

import { assertName } from 'graphql/type';

assertName('User'); // => 'User'
assertName('123User'); // throws an error

function assertNamedType

assertNamedType: (type: unknown) => GraphQLNamedType;

Returns the value as a GraphQL named type, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQL named type.

Example 1

import { GraphQLList, GraphQLString, assertNamedType } from 'graphql/type';

const namedType = assertNamedType(GraphQLString);

namedType.name; // => 'String'
assertNamedType(new GraphQLList(GraphQLString)); // throws an error

function assertNonNullType

assertNonNullType: (type: unknown) => GraphQLNonNull<GraphQLNullableType>;

Returns the value as a GraphQLNonNull, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQLNonNull.

Example 1

import { GraphQLNonNull, GraphQLString, assertNonNullType } from 'graphql/type';

const nonNullType = assertNonNullType(new GraphQLNonNull(GraphQLString));

nonNullType.ofType; // => GraphQLString
assertNonNullType(GraphQLString); // throws an error

function assertNullableType

assertNullableType: (type: unknown) => GraphQLNullableType;

Returns the value as a nullable GraphQL type, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a nullable GraphQL type.

Example 1

import {
  GraphQLNonNull,
  GraphQLString,
  assertNullableType,
} from 'graphql/type';

const nullableType = assertNullableType(GraphQLString);

nullableType; // => GraphQLString
assertNullableType(new GraphQLNonNull(GraphQLString)); // throws an error

function assertObjectType

assertObjectType: (type: unknown) => GraphQLObjectType;

Returns the value as a GraphQLObjectType, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQLObjectType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertObjectType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type User {
    name: String
  }

  type Query {
    user: User
  }
`);

const userType = assertObjectType(schema.getType('User'));

Object.keys(userType.getFields()); // => ['name']
assertObjectType(schema.getType('ReviewInput')); // throws an error

function assertOutputType

assertOutputType: (type: unknown) => GraphQLOutputType;

Returns the value as a GraphQL output type, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQL output type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertOutputType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type Review {
    stars: Int!
  }

  type Query {
    review(input: ReviewInput): Review
  }
`);

const outputType = assertOutputType(schema.getType('Review'));

outputType.toString(); // => 'Review'
assertOutputType(schema.getType('ReviewInput')); // throws an error

function assertScalarType

assertScalarType: (type: unknown) => GraphQLScalarType;

Returns the value as a GraphQLScalarType, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQLScalarType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertScalarType } from 'graphql/type';

const schema = buildSchema(`
  scalar DateTime

  type Query {
    createdAt: DateTime
  }
`);

const dateTimeType = assertScalarType(schema.getType('DateTime'));

dateTimeType.name; // => 'DateTime'
assertScalarType(schema.getType('Query')); // throws an error

function assertSchema

assertSchema: (schema: unknown) => GraphQLSchema;

Returns the value as a GraphQLSchema, or throws if it is not a schema.

Parameter schema

GraphQL schema to use.

Returns

The value typed as a GraphQLSchema.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertSchema, GraphQLString } from 'graphql/type';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);

assertSchema(schema); // => schema
assertSchema(GraphQLString); // throws an error

function assertType

assertType: (type: unknown) => GraphQLType;

Returns the value as a GraphQL type, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQL type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertType } from 'graphql/type';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const queryType = assertType(schema.getType('Query'));

queryType.toString(); // => 'Query'
assertType('Query'); // throws an error

function assertUnionType

assertUnionType: (type: unknown) => GraphQLUnionType;

Returns the value as a GraphQLUnionType, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQLUnionType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertUnionType } from 'graphql/type';

const schema = buildSchema(`
  type Photo {
    url: String!
  }

  type Video {
    url: String!
  }

  union Media = Photo | Video

  type Query {
    media: [Media]
  }
`);

const mediaType = assertUnionType(schema.getType('Media'));

mediaType.getTypes().map((type) => type.name); // => ['Photo', 'Video']
assertUnionType(schema.getType('Photo')); // throws an error

function assertValidSchema

assertValidSchema: (schema: GraphQLSchema) => void;

Utility function which asserts a schema is valid by throwing an error if it is invalid.

Parameter schema

GraphQL schema to use.

Example 1

import { assertValidSchema } from 'graphql/type';
import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

assertValidSchema(schema); // does not throw

function assertWrappingType

assertWrappingType: (type: unknown) => GraphQLWrappingType;

Returns the value as a GraphQL wrapping type, or throws if it is not one.

Parameter type

The GraphQL type to inspect.

Returns

The value typed as a GraphQL wrapping type.

Example 1

import { GraphQLList, GraphQLString, assertWrappingType } from 'graphql/type';

const wrappingType = assertWrappingType(new GraphQLList(GraphQLString));

wrappingType.toString(); // => '[String]'
assertWrappingType(GraphQLString); // throws an error

function astFromValue

astFromValue: (value: unknown, type: GraphQLInputType) => Maybe<ConstValueNode>;

Produces a GraphQL Value AST given a JavaScript object. Function will match JavaScript/JSON values to GraphQL AST schema format by using suggested GraphQLInputType.
A GraphQL type must be provided, which will be used to interpret different JavaScript values.
This deprecated function will be removed in v18. Use valueToLiteral() instead, and take care to operate on external values.
| JSON Value | GraphQL Value | | ------------- | -------------------- | | Object | Input Object | | Array | List | | Boolean | Boolean | | String | String / Enum Value | | Number | Int / Float | | BigInt | Int | | Unknown | Enum Value | | null | NullValue |
Parameter value
Runtime value to convert.
Parameter type
The GraphQL type to inspect.
Returns
A GraphQL value AST for the provided JavaScript value, or null when no literal can represent it.
Example 1
import { print } from 'graphql/language'; import { GraphQLInputObjectType, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLString, } from 'graphql/type'; import { astFromValue } from 'graphql/utilities'; const ReviewInput = new GraphQLInputObjectType({ name: 'ReviewInput', fields: { stars: { type: new GraphQLNonNull(GraphQLInt) }, tags: { type: new GraphQLList(GraphQLString) }, }, }); const valueNode = astFromValue( { stars: 5, tags: ['featured', 'verified'] }, ReviewInput, ); print(valueNode); // => '{ stars: 5, tags: ["featured", "verified"] }' astFromValue(undefined, GraphQLString); // => null astFromValue(null, new GraphQLNonNull(GraphQLString)); // => null
Deprecated
use valueToLiteral() instead with care to operate on external values - astFromValue() will be removed in v18

function buildASTSchema

buildASTSchema: (
    documentAST: DocumentNode,
    options?: BuildSchemaOptions
) => GraphQLSchema;

Builds a GraphQLSchema from a parsed schema definition language document.

If no schema definition is provided, then it will look for types named Query, Mutation and Subscription.

The resulting schema has no resolver functions, so execution will use the default field resolver.

Parameter documentAST

The parsed GraphQL document AST.

Parameter options

Optional configuration for this operation.

Returns

The schema built from the provided SDL document.

Example 1

// Build a schema from a valid parsed SDL document.
import { parse } from 'graphql/language';
import { buildASTSchema } from 'graphql/utilities';

const document = parse('type Query { hello: String }');
const schema = buildASTSchema(document);

schema.getQueryType().name; // => 'Query'

Example 2

// This variant uses validation options when the SDL references unknown types.
import { parse } from 'graphql/language';
import { buildASTSchema } from 'graphql/utilities';

const document = parse('type Query { broken: MissingType }');

buildASTSchema(document); // throws an error
buildASTSchema(document, {
  assumeValid: true,
  assumeValidSDL: true,
}); // does not throw

function buildClientSchema

buildClientSchema: (
    introspection: IntrospectionQuery,
    options?: GraphQLSchemaValidationOptions
) => GraphQLSchema;

Build a GraphQLSchema for use by client tools.
Given the result of a client running the introspection query, creates and returns a GraphQLSchema instance which can be then used with all graphql-js tools, but cannot be used to execute a query, as introspection does not represent the "resolver", "parse" or "serialize" functions or any other server-internal mechanisms.
This function expects a complete introspection result. Don't forget to check the "errors" field of a server response before calling this function.
Parameter introspection
Introspection result data to build from.
Parameter options
Optional configuration for this operation.
Returns
The client schema represented by the introspection result.
Example 1
import { buildClientSchema, introspectionFromSchema, buildSchema, } from 'graphql/utilities'; const schema = buildSchema('type Query { hello: String }'); const clientSchema = buildClientSchema(introspectionFromSchema(schema), { assumeValid: true, }); clientSchema.getQueryType().name; // => 'Query'

function buildSchema

buildSchema: (
    source: string | Source,
    options?: BuildSchemaOptions & ParseOptions
) => GraphQLSchema;

Builds a GraphQLSchema directly from a schema definition language source.

Parameter source

The GraphQL source text or source object.

Parameter options

Optional configuration for this operation.

Returns

The schema built from the provided SDL document.

Example 1

// Build a schema from SDL source using the default options.
import { buildSchema } from 'graphql/utilities';

const schema = buildSchema('type Query { hello: String }');

schema.getQueryType().name; // => 'Query'

Example 2

// This variant enables parser options and omits source locations.
import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(
  'directive @tag on FIELD_DEFINITION\n' +
    'directive @compose @tag on FIELD_DEFINITION',
  {
    experimentalFragmentArguments: true,
    noLocation: true,
  },
);

const directive = schema.getDirective('compose');

directive.name; // => 'compose'
directive.astNode.loc; // => undefined

function coerceInputLiteral

coerceInputLiteral: (
    valueNode: ValueNode,
    type: GraphQLInputType,
    variableValues?: Maybe<VariableValues>,
    fragmentVariableValues?: Maybe<FragmentVariableValues>
) => unknown;

Produces a coerced "internal" JavaScript value given a GraphQL Value AST.

Returns undefined when the value could not be validly coerced according to the provided type.

Parameter valueNode

GraphQL value AST node to coerce.

Parameter type

GraphQL input type to coerce the literal against.

Parameter variableValues

Operation variable values returned by getVariableValues.

Parameter fragmentVariableValues

Fragment variable values for the current fragment scope.

Returns

Coerced value, or undefined if coercion fails.

Example 1

// Coerce literal input values without variables.
import { parseValue } from 'graphql/language';
import {
  GraphQLInputObjectType,
  GraphQLInt,
  GraphQLNonNull,
  GraphQLString,
} from 'graphql/type';
import { coerceInputLiteral } from 'graphql/utilities';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {
    stars: { type: new GraphQLNonNull(GraphQLInt) },
    comment: { type: GraphQLString },
  },
});

coerceInputLiteral(
  parseValue('{ stars: 5, comment: "Loved it" }'),
  ReviewInput,
); // => { stars: 5, comment: 'Loved it' }
coerceInputLiteral(parseValue('{ comment: "Missing" }'), ReviewInput); // => undefined

Example 2

// This variant resolves variable references using VariableValues from getVariableValues().
import assert from 'node:assert';
import { parse, parseValue } from 'graphql/language';
import { GraphQLInt } from 'graphql/type';
import { getVariableValues } from 'graphql/execution';
import { buildSchema, coerceInputLiteral } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    review(stars: Int): String
  }
`);
const document = parse('query ($stars: Int = 5) { review(stars: $stars) }');
const operation = document.definitions[0];
const result = getVariableValues(schema, operation.variableDefinitions, {
  stars: '4',
});

assert('variableValues' in result);

coerceInputLiteral(parseValue('$stars'), GraphQLInt, result.variableValues); // => 4

function coerceInputValue

coerceInputValue: (inputValue: unknown, type: GraphQLInputType) => unknown;

Coerces a JavaScript value given a GraphQL Input Type.

Returns undefined when the value could not be validly coerced according to the provided type. Use validateInputValue when coercion diagnostics are needed.

Parameter inputValue

JavaScript value to coerce.

Parameter type

GraphQL input type to coerce the value against.

Returns

Coerced value, or undefined if coercion fails.

Example 1

// Coerce runtime input values, returning undefined when coercion fails.
import {
  GraphQLInputObjectType,
  GraphQLInt,
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
} from 'graphql/type';
import { coerceInputValue } from 'graphql/utilities';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {
    stars: { type: new GraphQLNonNull(GraphQLInt) },
    tags: { type: new GraphQLList(GraphQLString) },
  },
});

coerceInputValue({ stars: '5', tags: ['featured'] }, ReviewInput); // => { stars: 5, tags: ['featured'] }
coerceInputValue({ stars: 'bad' }, ReviewInput); // => undefined

function concatAST

concatAST: (documents: ReadonlyArray<DocumentNode>) => DocumentNode;

Provided a collection of ASTs, presumably each from different files, concatenate the ASTs together into batched AST, useful for validating many GraphQL source files which together represent one conceptual application.
Parameter documents
Document ASTs to concatenate.
Returns
A document AST containing all definitions from the provided documents.
Example 1
import { parse } from 'graphql/language'; import { concatAST } from 'graphql/utilities'; const document = concatAST([ parse('type Query { a: String }'), parse('type User { id: ID }'), ]); document.definitions.length; // => 2

function createSourceEventStream

createSourceEventStream: (
    validatedExecutionArgs: ValidatedSubscriptionArgs
) => PromiseOrValue<AsyncIterable<unknown> | ExecutionResult>;

Implements the "CreateSourceEventStream" algorithm described in the GraphQL specification, resolving the subscription source event stream for a previously validated subscription request.
Returns either an AsyncIterable (if successful), an ExecutionResult (error), or a Promise for one of those results. The call will throw immediately if it is not passed validated execution arguments.
If the validated arguments do not result in a compliant subscription, a GraphQL Response (ExecutionResult) with descriptive errors and no data will be returned.
If the source stream could not be created due to faulty subscription resolver logic or a system error, the function will return or resolve to a single ExecutionResult containing errors and no data.
If the operation succeeded, the function returns or resolves to the AsyncIterable for the event stream returned by the resolver.
A Source Event Stream represents a sequence of events, each of which triggers a GraphQL execution for that event.
This may be useful when hosting the stateful subscription service in a different process or machine than the stateless GraphQL execution engine, or otherwise separating these two steps. For more on this, see the "Supporting Subscriptions at Scale" information in the GraphQL specification.
Parameter validatedExecutionArgs
Validated subscription execution arguments.
Returns
A source event stream, or an execution result containing errors.
Example 1
import assert from 'node:assert'; import { parse } from 'graphql/language'; import { buildSchema } from 'graphql/utilities'; import { createSourceEventStream, validateSubscriptionArgs, } from 'graphql/execution'; async function* greetings() { yield { greeting: 'Hello' }; } const schema = buildSchema(` type Query { noop: String } type Subscription { greeting: String } `); const validatedArgs = validateSubscriptionArgs({ schema, document: parse('subscription { greeting }'), rootValue: { greeting: () => greetings() }, }); assert('schema' in validatedArgs); const stream = await createSourceEventStream(validatedArgs); Symbol.asyncIterator in stream; // => true

function DeferStreamDirectiveLabelRule

DeferStreamDirectiveLabelRule: (context: ValidationContext) => ASTVisitor;

Defer and stream directive labels are unique

A GraphQL document is only valid if defer and stream directives' label argument is static and unique.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { validate, DeferStreamDirectiveLabelRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    friends: [String]
  }
`);
const invalidDocument = parse(`
  {
    friends @stream(label: "friends")
    other: friends @stream(label: "friends")
  }
`);
const validDocument = parse(`
  {
    friends @stream(label: "friends")
    other: friends @stream(label: "otherFriends")
  }
`);

validate(schema, invalidDocument, [DeferStreamDirectiveLabelRule]).length; // => 1
validate(schema, validDocument, [DeferStreamDirectiveLabelRule]); // => []

function DeferStreamDirectiveOnRootFieldRule

DeferStreamDirectiveOnRootFieldRule: (context: ValidationContext) => ASTVisitor;

Defer and stream directives are used on valid root field

A GraphQL document is only valid if defer directives are not used on root mutation or subscription types.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import {
  validate,
  DeferStreamDirectiveOnRootFieldRule,
} from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    message: String
  }

  type Mutation {
    updateMessage: String
  }
`);
const invalidDocument = parse(`
  mutation { ... @defer { updateMessage } }
`);
const validDocument = parse(`
  { ... @defer { message } }
`);

validate(schema, invalidDocument, [DeferStreamDirectiveOnRootFieldRule]).length; // => 1
validate(schema, validDocument, [DeferStreamDirectiveOnRootFieldRule]); // => []

function DeferStreamDirectiveOnValidOperationsRule

DeferStreamDirectiveOnValidOperationsRule: (
    context: ValidationContext
) => ASTVisitor;

Defer And Stream Directives Are Used On Valid Operations

A GraphQL document is only valid if defer and stream directives are not used on root mutation or subscription types.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import {
  validate,
  DeferStreamDirectiveOnValidOperationsRule,
} from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    message: Message
  }

  type Subscription {
    message: Message
  }

  type Message {
    body: String
  }
`);
const invalidDocument = parse(`
  subscription {
    message {
      ...MessageBody @defer
    }
  }

  fragment MessageBody on Message {
    body
  }
`);
const validDocument = parse(`
  subscription {
    message {
      ...MessageBody @defer(if: false)
    }
  }

  fragment MessageBody on Message {
    body
  }
`);

validate(schema, invalidDocument, [DeferStreamDirectiveOnValidOperationsRule])
  .length; // => 1
validate(schema, validDocument, [DeferStreamDirectiveOnValidOperationsRule]); // => []

function doTypesOverlap

doTypesOverlap: (
    schema: GraphQLSchema,
    typeA: GraphQLCompositeType,
    typeB: GraphQLCompositeType
) => boolean;

Provided two composite types, determine if they "overlap". Two composite types overlap when the Sets of possible concrete types for each intersect.

This is often used to determine if a fragment of a given type could possibly be visited in a context of another type.

This function is commutative.

Parameter schema

GraphQL schema to use.

Parameter typeA

The first GraphQL type to compare.

Parameter typeB

The second GraphQL type to compare.

Returns

True when the two composite types can apply to at least one common object type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertObjectType, assertUnionType } from 'graphql/type';
import { doTypesOverlap } from 'graphql/utilities';

const schema = buildSchema(`
  type Photo {
    url: String!
  }

  type Video {
    url: String!
  }

  union Media = Photo | Video
  union StillImage = Photo

  type Query {
    media: [Media]
  }
`);
const Media = assertUnionType(schema.getType('Media'));
const StillImage = assertUnionType(schema.getType('StillImage'));
const Video = assertObjectType(schema.getType('Video'));

doTypesOverlap(schema, Media, StillImage); // => true
doTypesOverlap(schema, StillImage, Video); // => false

function enableDevMode

enableDevMode: () => void;

Enables GraphQL.js development mode checks for this module instance.
Production entry points leave development mode disabled by default. Call this before constructing schemas or executing requests when additional development diagnostics should run.
Example 1
import { enableDevMode, isDevModeEnabled } from 'graphql/devMode'; isDevModeEnabled(); // => false enableDevMode(); isDevModeEnabled(); // => true

function ExecutableDefinitionsRule

ExecutableDefinitionsRule: (context: ASTValidationContext) => ASTVisitor;

Executable definitions

A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.

See https://spec.graphql.org/draft/#sec-Executable-Definitions

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { ExecutableDefinitionsRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  type Extra { field: String }
`);
const invalidErrors = validate(schema, invalidDocument, [
  ExecutableDefinitionsRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { name }
`);
const validErrors = validate(schema, validDocument, [
  ExecutableDefinitionsRule,
]);

validErrors; // => []

function execute

execute: (args: ExecutionArgs) => PromiseOrValue<ExecutionResult>;

Implements the "Executing requests" section of the GraphQL specification.
Returns either a synchronous ExecutionResult (if all encountered resolvers are synchronous), or a Promise of an ExecutionResult that will eventually be resolved and never rejected.
If the schema is invalid, an error will be thrown immediately. GraphQL request errors, including missing operations and variable coercion errors, are returned in an errors-only ExecutionResult.
Field errors are collected into the response instead of rejecting the returned promise. Only the field that produced the error and its descendants are omitted; sibling fields continue to execute. Errors from fields of non-null type may propagate to the nearest nullable parent, which can be the entire response data.
This function does not support incremental delivery (@defer and @stream). Use experimentalExecuteIncrementally to execute operations with incremental delivery enabled.
Parameter args
The arguments used to perform the operation.
Returns
A completed execution result, or a promise resolving to one when execution is asynchronous.
Example 1
import { parse } from 'graphql/language'; import { buildSchema } from 'graphql/utilities'; import { execute } from 'graphql/execution'; const schema = buildSchema(` type Query { greeting(name: String!): String } `); const result = await execute({ schema, document: parse('query ($name: String!) { greeting(name: $name) }'), rootValue: { greeting: ({ name }) => `Hello, ${name}!`, }, variableValues: { name: 'Ada' }, }); result; // => { data: { greeting: 'Hello, Ada!' } }

function executeRootSelectionSet

executeRootSelectionSet: (
    validatedExecutionArgs: ValidatedExecutionArgs
) => PromiseOrValue<ExecutionResult>;

Implements the "Executing operations" section of the spec.
Returns either a synchronous ExecutionResult, or a Promise for an ExecutionResult, described by the "Response" section of the GraphQL specification.
If errors are encountered while executing a GraphQL field, only that field and its descendants will be omitted, and sibling fields will still be executed. These field errors are collected into the returned result instead of being thrown or rejecting the returned promise.
Errors from sub-fields of a NonNull type may propagate to the top level, at which point we still collect the error and null the parent field, which in this case is the entire response.
Parameter validatedExecutionArgs
Validated execution arguments.
Returns
Execution result for the operation root selection set.
Example 1
import assert from 'node:assert'; import { parse } from 'graphql/language'; import { buildSchema } from 'graphql/utilities'; import { executeRootSelectionSet, validateExecutionArgs, } from 'graphql/execution'; const schema = buildSchema('type Query { greeting: String }'); const validatedArgs = validateExecutionArgs({ schema, document: parse('{ greeting }'), rootValue: { greeting: 'Hello' }, }); assert('schema' in validatedArgs); const result = await executeRootSelectionSet(validatedArgs); result; // => { data: { greeting: 'Hello' } }

function executeSubscriptionEvent

executeSubscriptionEvent: (
    validatedExecutionArgs: ValidatedSubscriptionArgs
) => PromiseOrValue<ExecutionResult>;

Executes a subscription operation once for a single source event.

Field errors are collected into the returned result instead of being thrown or rejecting the returned promise.

Parameter validatedExecutionArgs

Validated subscription execution arguments.

Returns

Execution result for the subscription event.

Example 1

import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import {
  executeSubscriptionEvent,
  validateSubscriptionArgs,
} from 'graphql/execution';

const schema = buildSchema(`
  type Query {
    noop: String
  }

  type Subscription {
    greeting: String
  }
`);
const validatedArgs = validateSubscriptionArgs({
  schema,
  document: parse('subscription { greeting }'),
  rootValue: { greeting: 'Hello' },
});

assert('schema' in validatedArgs);

const result = await executeSubscriptionEvent(validatedArgs);
result; // => { data: { greeting: 'Hello' } }

function executeSync

executeSync: (args: ExecutionArgs) => ExecutionResult;

Also implements the "Executing requests" section of the GraphQL specification. However, it guarantees to complete synchronously (or throw an error) assuming that all field resolvers are also synchronous.

Parameter args

The arguments used to perform the operation.

Returns

Completed execution output for a synchronous operation.

Example 1

import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { executeSync } from 'graphql/execution';

const schema = buildSchema('type Query { greeting: String }');

const result = executeSync({
  schema,
  document: parse('{ greeting }'),
  rootValue: { greeting: 'Hello' },
});

result; // => { data: { greeting: 'Hello' } }

function experimentalExecuteIncrementally

experimentalExecuteIncrementally: (
    args: ExecutionArgs
) => PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults>;

Implements the "Executing requests" section of the GraphQL specification, including @defer and @stream as proposed in https://github.com/graphql/graphql-spec/pull/742
This function returns either a single ExecutionResult, or an ExperimentalIncrementalExecutionResults object containing an initialResult and a stream of subsequentResults.
If the schema is invalid, an error will be thrown immediately. GraphQL request errors, including missing operations and variable coercion errors, are returned in an errors-only ExecutionResult.
Parameter args
Execution arguments for the GraphQL operation.
Returns
A single execution result or incremental execution results.
Example 1
import { parse } from 'graphql/language'; import { buildSchema } from 'graphql/utilities'; import { experimentalExecuteIncrementally } from 'graphql/execution'; const schema = buildSchema(` type Query { greeting: String } `); const result = await experimentalExecuteIncrementally({ schema, document: parse('{ greeting }'), rootValue: { greeting: 'Hello' }, }); result; // => { data: { greeting: 'Hello' } }
Incremental Execution

function experimentalExecuteRootSelectionSet

experimentalExecuteRootSelectionSet: (
    validatedExecutionArgs: ValidatedExecutionArgs
) => PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults>;

Executes the operation root selection set with incremental delivery enabled.

Parameter validatedExecutionArgs

Validated execution arguments.

Returns

A single execution result or incremental execution results.

Example 1

import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import {
  experimentalExecuteRootSelectionSet,
  validateExecutionArgs,
} from 'graphql/execution';

const schema = buildSchema('type Query { greeting: String }');
const validatedArgs = validateExecutionArgs({
  schema,
  document: parse('{ greeting }'),
  rootValue: { greeting: 'Hello' },
});

assert('schema' in validatedArgs);

const result = await experimentalExecuteRootSelectionSet(validatedArgs);
result; // => { data: { greeting: 'Hello' } }

Incremental Execution

function extendSchema

extendSchema: (
    schema: GraphQLSchema,
    documentAST: DocumentNode,
    options?: Options
) => GraphQLSchema;

Produces a new schema given an existing schema and a document which may contain GraphQL type extensions and definitions. The original schema will remain unaltered.

Because a schema represents a graph of references, a schema cannot be extended without effectively making an entire copy. We do not know until it's too late if subgraphs remain unchanged.

This algorithm copies the provided schema, applying extensions while producing the copy. The original schema remains unaltered.

Parameter schema

GraphQL schema to use.

Parameter documentAST

The parsed GraphQL document AST.

Parameter options

Optional configuration for this operation.

Returns

A new schema with the extensions and definitions applied.

Example 1

// Extend a schema with new fields and types.
import { parse } from 'graphql/language';
import { buildSchema, extendSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const extensionAST = parse(`
  extend type Query {
    farewell: String
  }

  type Review {
    body: String
  }
`);

const extendedSchema = extendSchema(schema, extensionAST);

schema.getType('Review'); // => undefined
extendedSchema.getType('Review')?.name; // => 'Review'
Object.keys(extendedSchema.getQueryType().getFields()); // => ['greeting', 'farewell']

Example 2

// This variant bypasses validation for an otherwise invalid extension.
import { parse } from 'graphql/language';
import { buildSchema, extendSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const invalidExtension = parse(`
  extend type Missing {
    field: String
  }
`);

extendSchema(schema, invalidExtension); // throws an error
extendSchema(schema, invalidExtension, {
  assumeValid: true,
  assumeValidSDL: true,
}); // does not throw

function FieldsOnCorrectTypeRule

FieldsOnCorrectTypeRule: (context: ValidationContext) => ASTVisitor;

Fields on correct type

A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as __typename.

See https://spec.graphql.org/draft/#sec-Field-Selections

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { FieldsOnCorrectTypeRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  { missing }
`);
const invalidErrors = validate(schema, invalidDocument, [
  FieldsOnCorrectTypeRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { name }
`);
const validErrors = validate(schema, validDocument, [FieldsOnCorrectTypeRule]);

validErrors; // => []

function findBreakingChanges

findBreakingChanges: (
    oldSchema: GraphQLSchema,
    newSchema: GraphQLSchema
) => Array<BreakingChange>;

Given two schemas, returns an Array containing descriptions of all the types of breaking changes covered by the other functions down below. This deprecated wrapper will be removed in v18; use findSchemaChanges() instead and filter for breaking changes.
Parameter oldSchema
Schema before the change.
Parameter newSchema
Schema after the change.
Returns
Breaking changes between the two schemas.
Example 1
import { buildSchema, findBreakingChanges } from 'graphql/utilities'; const oldSchema = buildSchema(` type Query { greeting: String } `); const newSchema = buildSchema(` type Query { hello: String } `); const changes = findBreakingChanges(oldSchema, newSchema); changes.map((change) => change.type); // => ['FIELD_REMOVED']
Deprecated
Please use findSchemaChanges instead. Will be removed in v18.

function findDangerousChanges

findDangerousChanges: (
    oldSchema: GraphQLSchema,
    newSchema: GraphQLSchema
) => Array<DangerousChange>;

Given two schemas, returns an Array containing descriptions of all the types of potentially dangerous changes covered by the other functions down below. This deprecated wrapper will be removed in v18; use findSchemaChanges() instead and filter for dangerous changes.

Parameter oldSchema

Schema before the change.

Parameter newSchema

Schema after the change.

Returns

Dangerous changes between the two schemas.

Example 1

import { buildSchema, findDangerousChanges } from 'graphql/utilities';

const oldSchema = buildSchema(`
  enum Episode {
    NEW_HOPE
  }

  type Query {
    episode: Episode
  }
`);
const newSchema = buildSchema(`
  enum Episode {
    NEW_HOPE
    EMPIRE
  }

  type Query {
    episode: Episode
  }
`);

const changes = findDangerousChanges(oldSchema, newSchema);

changes.map((change) => change.type); // => ['VALUE_ADDED_TO_ENUM']

Deprecated

Please use findSchemaChanges instead. Will be removed in v18.

function findSchemaChanges

findSchemaChanges: (
    oldSchema: GraphQLSchema,
    newSchema: GraphQLSchema
) => Array<SchemaChange>;

Finds all schema changes between two schemas.

Parameter oldSchema

Schema before the change.

Parameter newSchema

Schema after the change.

Returns

Safe, dangerous, and breaking changes between the two schemas.

Example 1

import { buildSchema, findSchemaChanges } from 'graphql/utilities';

const oldSchema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const newSchema = buildSchema(`
  type Query {
    greeting(name: String): String
    farewell: String
  }
`);

const changes = findSchemaChanges(oldSchema, newSchema);

changes.map((change) => change.type); // => ['OPTIONAL_ARG_ADDED', 'FIELD_ADDED']

function FragmentsOnCompositeTypesRule

FragmentsOnCompositeTypesRule: (context: ValidationContext) => ASTVisitor;

Fragments on composite type

Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.

See https://spec.graphql.org/draft/#sec-Fragments-On-Composite-Types

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { FragmentsOnCompositeTypesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  fragment Bad on String { length }
`);
const invalidErrors = validate(schema, invalidDocument, [
  FragmentsOnCompositeTypesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  fragment Good on Query { name }
`);
const validErrors = validate(schema, validDocument, [
  FragmentsOnCompositeTypesRule,
]);

validErrors; // => []

function getArgumentValues

getArgumentValues: (
    def: GraphQLField<unknown, unknown> | GraphQLDirective,
    node: FieldNode | DirectiveNode,
    variableValues?: Maybe<VariableValues>,
    fragmentVariableValues?: Maybe<FragmentVariableValues>,
    hideSuggestions?: Maybe<boolean>
) => ObjMap<unknown>;

Prepares an object map of argument values given a list of argument definitions and list of argument AST nodes.

Note: Returned value uses a null prototype to avoid collisions with JavaScript's own property names.

Parameter def

Field or directive definition that declares the arguments.

Parameter node

Field or directive AST node supplying argument literals.

Parameter variableValues

Operation variable values returned by getVariableValues.

Parameter fragmentVariableValues

Fragment variable values for the current fragment scope.

Parameter hideSuggestions

Whether suggestion text should be omitted from errors.

Returns

A map of coerced argument values.

Example 1

// Read literal argument values and defaults.
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { getArgumentValues } from 'graphql/execution';

const schema = buildSchema(`
  type Query {
    reviews(stars: Int!, limit: Int = 10): [String]
  }
`);
const fieldDef = schema.getQueryType().getFields().reviews;
const document = parse('{ reviews(stars: 5) }');
const fieldNode = document.definitions[0].selectionSet.selections[0];

getArgumentValues(fieldDef, fieldNode); // => { stars: 5, limit: 10 }

Example 2

// This variant resolves argument values from operation variables.
import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { getArgumentValues, getVariableValues } from 'graphql/execution';

const schema = buildSchema(`
  type Query {
    reviews(stars: Int!): [String]
  }
`);
const fieldDef = schema.getQueryType().getFields().reviews;
const document = parse('query ($stars: Int!) { reviews(stars: $stars) }');
const operation = document.definitions[0];
const fieldNode = document.definitions[0].selectionSet.selections[0];
const variables = getVariableValues(schema, operation.variableDefinitions, {
  stars: '5',
});

assert('variableValues' in variables);

getArgumentValues(fieldDef, fieldNode, variables.variableValues); // => { stars: 5 }
getArgumentValues(fieldDef, fieldNode); // throws an error

function getDirectiveValues

getDirectiveValues: (
    directiveDef: GraphQLDirective,
    node: { readonly directives?: ReadonlyArray<DirectiveNode> | undefined },
    variableValues?: Maybe<VariableValues>,
    fragmentVariableValues?: Maybe<FragmentVariableValues>,
    hideSuggestions?: Maybe<boolean>
) => undefined | ObjMap<unknown>;

Prepares an object map of argument values given a directive definition and a AST node which may contain directives. Optionally also accepts a map of variable values.

If the directive does not exist on the node, returns undefined.

Note: Returned value uses a null prototype to avoid collisions with JavaScript's own property names.

Parameter directiveDef

Directive definition to read argument definitions from.

Parameter node

AST node that may contain directives.

Parameter

node.directives - The directives on the AST node.

Parameter variableValues

Operation variable values returned by getVariableValues.

Parameter fragmentVariableValues

Fragment variable values for the current fragment scope.

Parameter hideSuggestions

Whether suggestion text should be omitted from errors.

Returns

A map of coerced directive argument values, or undefined when absent.

Example 1

// Read literal directive arguments from a node.
import { parse } from 'graphql/language';
import { GraphQLSkipDirective } from 'graphql/type';
import { getDirectiveValues } from 'graphql/execution';

const document = parse('{ name @skip(if: true) }');
const fieldNode = document.definitions[0].selectionSet.selections[0];

getDirectiveValues(GraphQLSkipDirective, fieldNode); // => { if: true }

Example 2

// This variant resolves directive arguments from variables and handles absent directives.
import assert from 'node:assert';
import { parse } from 'graphql/language';
import { GraphQLIncludeDirective } from 'graphql/type';
import { buildSchema } from 'graphql/utilities';
import { getDirectiveValues, getVariableValues } from 'graphql/execution';

const schema = buildSchema('type Query { name: String }');
const document = parse(
  'query ($includeName: Boolean!) { name @include(if: $includeName) }',
);
const operation = document.definitions[0];
const fieldNode = document.definitions[0].selectionSet.selections[0];
const variables = getVariableValues(schema, operation.variableDefinitions, {
  includeName: false,
});

assert('variableValues' in variables);

getDirectiveValues(
  GraphQLIncludeDirective,
  fieldNode,
  variables.variableValues,
); // => { if: false }
getDirectiveValues(GraphQLIncludeDirective, { directives: [] }); // => undefined

function getEnterLeaveForKind

getEnterLeaveForKind: (
    visitor: ASTVisitor,
    kind: Kind
) => EnterLeaveVisitor<ASTNode>;

Given a visitor instance and a node kind, return EnterLeaveVisitor for that kind.
Parameter visitor
The visitor object to inspect.
Parameter kind
The AST node kind to resolve handlers for.
Returns
The enter and leave handlers that apply for the given node kind.
Example 1
import { Kind, getEnterLeaveForKind } from 'graphql/language'; const handlers = getEnterLeaveForKind({ Field: () => {} }, Kind.FIELD); typeof handlers.enter; // => 'function' handlers.leave; // => undefined

function getIntrospectionQuery

getIntrospectionQuery: (options?: IntrospectionOptions) => string;

Produce the GraphQL query recommended for a full schema introspection. Accepts optional IntrospectionOptions.

Parameter options

Optional configuration for this operation.

Returns

The resolved introspection query.

Example 1

// Generate the default introspection query.
import { getIntrospectionQuery } from 'graphql/utilities';

const query = getIntrospectionQuery();

query; // matches /__schema/
query; // matches /description/
query; // does not match /specifiedByURL/

Example 2

// This variant customizes optional introspection fields and nesting depth.
import { getIntrospectionQuery } from 'graphql/utilities';

const query = getIntrospectionQuery({
  descriptions: false,
  specifiedByUrl: true,
  directiveIsRepeatable: true,
  schemaDescription: true,
  inputValueDeprecation: true,
  experimentalDirectiveDeprecation: true,
  oneOf: true,
  typeDepth: 3,
});

query; // does not match /description/
query; // matches /specifiedByURL/
query; // matches /isRepeatable/
query; // matches /includeDeprecated: true/
query; // matches /isOneOf/
(query.match(/ofType/g)?.length ?? 0) > 0; // => true

function getLocation

getLocation: (source: Source, position: number) => SourceLocation;

Takes a Source and a UTF-8 character offset, and returns the corresponding line and column as a SourceLocation.
Parameter source
The source document that contains the position.
Parameter position
The UTF-8 character offset in the source body.
Returns
The 1-indexed line and column for the given source position.
Example 1
import { Source, getLocation } from 'graphql/language'; const source = new Source('type Query { hello: String }'); const location = getLocation(source, 13); location; // => { line: 1, column: 14 }

function getNamedType

getNamedType: {
    (type: undefined | null): void;
    (type: GraphQLInputType): GraphQLNamedInputType;
    (type: GraphQLOutputType): GraphQLNamedOutputType;
    (type: GraphQLType): GraphQLNamedType;
    (type: GraphQLType): GraphQLNamedType;
};

Returns the named type.
Parameter type
The GraphQL type to inspect.
Returns
The named type after unwrapping all list and non-null wrappers.
Example 1
import { getNamedType } from 'graphql/type'; getNamedType(null); // => undefined getNamedType(undefined); // => undefined

Returns the named input type after unwrapping all list and non-null wrappers.

Parameter type

The GraphQL input type to inspect.

Returns

The named input type after unwrapping all wrappers.

Example 1

import { buildSchema } from 'graphql/utilities';
import { getNamedType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type Query {
    review(input: [ReviewInput!]!): Boolean
  }
`);

const inputArg = schema.getQueryType()?.getFields().review.args[0];

getNamedType(inputArg?.type).toString(); // => 'ReviewInput'

Returns the named output type after unwrapping all list and non-null wrappers.

Parameter type

The GraphQL output type to inspect.

Returns

The named output type after unwrapping all wrappers.

Example 1

import { buildSchema } from 'graphql/utilities';
import { getNamedType } from 'graphql/type';

const schema = buildSchema(`
  type User {
    name: String
  }

  type Query {
    users: [User!]!
  }
`);

const usersField = schema.getQueryType()?.getFields().users;

getNamedType(usersField?.type).toString(); // => 'User'

Returns the named type after unwrapping all list and non-null wrappers.

Parameter type

The GraphQL type to inspect.

Returns

The named type after unwrapping all wrappers.

Example 1

import {
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
  getNamedType,
} from 'graphql/type';

const nestedType = new GraphQLNonNull(
  new GraphQLList(new GraphQLNonNull(GraphQLString)),
);

getNamedType(nestedType); // => GraphQLString

Returns the named type after unwrapping all list and non-null wrappers.
Parameter type
The GraphQL type to inspect.
Returns
The named type after unwrapping all wrappers, or undefined for nullish input.
Example 1
import { GraphQLList, GraphQLString, getNamedType } from 'graphql/type'; getNamedType(new GraphQLList(GraphQLString)); // => GraphQLString getNamedType(undefined); // => undefined

function getNullableType

getNullableType: {
    (type: undefined | null): void;
    <T extends GraphQLNullableType>(type: T | GraphQLNonNull<T>): T;
    (type: GraphQLType): GraphQLNullableType;
};

Returns the nullable type.
Parameter type
The GraphQL type to inspect.
Returns
The nullable type after removing one non-null wrapper, if present.
Example 1
import { getNullableType } from 'graphql/type'; getNullableType(null); // => undefined getNullableType(undefined); // => undefined

Returns the nullable type after removing one non-null wrapper.

Parameter type

A nullable type or non-null wrapper.

Returns

The nullable type after removing one non-null wrapper, if present.

Example 1

import {
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
  getNullableType,
} from 'graphql/type';

const requiredString = new GraphQLNonNull(GraphQLString);
const stringList = new GraphQLList(GraphQLString);

getNullableType(requiredString); // => GraphQLString
getNullableType(stringList); // => stringList

Returns the nullable type after removing one non-null wrapper.

Parameter type

The GraphQL type to inspect.

Returns

The nullable type after removing one non-null wrapper, if present.

Example 1

import {
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
  getNullableType,
} from 'graphql/type';

const requiredStringList = new GraphQLNonNull(new GraphQLList(GraphQLString));

getNullableType(requiredStringList).toString(); // => '[String]'
getNullableType(GraphQLString); // => GraphQLString

function getOperationAST

getOperationAST: (
    documentAST: DocumentNode,
    operationName?: Maybe<string>
) => Maybe<OperationDefinitionNode>;

Returns an operation AST given a document AST and optionally an operation name. If a name is not provided, an operation is only returned if only one is provided in the document.
Parameter documentAST
The parsed GraphQL document AST.
Parameter operationName
The optional operation name to select.
Returns
The resolved operation ast.
Example 1
import { parse } from 'graphql/language'; import { getOperationAST } from 'graphql/utilities'; const document = parse('query GetName { name }'); const operation = getOperationAST(document, 'GetName'); operation.name.value; // => 'GetName' getOperationAST(document, 'Missing'); // => undefined

function getVariableValues

getVariableValues: (
    schema: GraphQLSchema,
    varDefNodes: ReadonlyArray<VariableDefinitionNode>,
    inputs: { readonly [variable: string]: unknown },
    options?: { maxErrors?: number; hideSuggestions?: boolean }
) => VariableValuesOrErrors;

Prepares an object map of variableValues of the correct type based on the provided variable definitions and arbitrary input. If the input cannot be parsed to match the variable definitions, GraphQLError values are returned.

Note: Returned maps use null prototypes to avoid collisions with Object prototype properties.

Parameter schema

GraphQL schema to use.

Parameter varDefNodes

The variable definition AST nodes to coerce.

Parameter inputs

The runtime variable values keyed by variable name.

Parameter options

Optional configuration for this operation.

Parameter

[options.maxErrors] - Maximum number of coercion errors to report.

Parameter

[options.hideSuggestions] - Whether suggestion text should be omitted from errors.

Returns

Coerced variable values with source metadata, or request errors.

Example 1

// Coerce provided variables and apply operation defaults.
import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { getVariableValues } from 'graphql/execution';

const schema = buildSchema(`
  type Query {
    reviews(stars: Int!, limit: Int = 10): [String]
  }
`);
const document = parse(`
  query ($stars: Int!, $limit: Int = 10) {
    reviews(stars: $stars, limit: $limit)
  }
`);
const operation = document.definitions[0];

const result = getVariableValues(schema, operation.variableDefinitions, {
  stars: '5',
});

assert('variableValues' in result);

result.variableValues.coerced; // => { stars: 5, limit: 10 }

Example 2

// This variant uses maxErrors to cap reported coercion errors.
import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { getVariableValues } from 'graphql/execution';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type Query {
    review(input: ReviewInput!): String
  }
`);
const document = parse(`
  query ($first: ReviewInput!, $second: ReviewInput!) {
    first: review(input: $first)
    second: review(input: $second)
  }
`);
const operation = document.definitions[0];

const result = getVariableValues(
  schema,
  operation.variableDefinitions,
  { first: { stars: 'bad' }, second: { stars: 'also bad' } },
  { maxErrors: 1 },
);

assert('errors' in result);

result.errors.length; // => 2
result.errors[1].message; // matches /error limit reached/

function graphql

graphql: (args: GraphQLArgs) => Promise<ExecutionResult>;

Parses, validates, and executes a GraphQL document against a schema.

This is the primary entry point for fulfilling GraphQL operations. Use this when you want a single-call request lifecycle that returns a promise in all cases.

More sophisticated GraphQL servers, such as those which persist queries, may wish to separate the validation and execution phases to a static-time tooling step and a server runtime step.

Parameter args

Request execution arguments, including schema and source.

Returns

A promise that resolves to an execution result or validation errors.

Example 1

// Execute a complete asynchronous request with variables.
import { graphql, buildSchema } from 'graphql';

const schema = buildSchema(`
  type Query {
    greeting(name: String!): String
  }
`);

const result = await graphql({
  schema,
  source: 'query SayHello($name: String!) { greeting(name: $name) }',
  rootValue: {
    greeting: ({ name }) => `Hello, ${name}!`,
  },
  variableValues: { name: 'Ada' },
  operationName: 'SayHello',
});

result; // => { data: { greeting: 'Hello, Ada!' } }

Example 2

// This variant supplies context plus custom field and type resolvers.
import { graphql, buildSchema } from 'graphql';

const schema = buildSchema(`
  interface Named {
    name: String!
  }

  type User implements Named {
    name: String!
  }

  type Query {
    viewer: Named
  }
`);

const result = await graphql({
  schema,
  source: '{ viewer { __typename name } }',
  rootValue: { viewer: { kind: 'user', name: 'Ada' } },
  contextValue: { locale: 'en' },
  fieldResolver: (source, _args, context, info) => {
    context.locale; // => 'en'
    return source[info.fieldName];
  },
  typeResolver: (value) => {
    return value.kind === 'user' ? 'User' : undefined;
  },
});

result; // => { data: { viewer: { __typename: 'User', name: 'Ada' } } }

Example 3

// This variant customizes the request pipeline with a harness.
import { buildSchema, defaultHarness, graphql } from 'graphql';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const stages = [];
const abortController = new AbortController();
const harness = {
  parse: (...args) => {
    stages.push('parse');
    return defaultHarness.parse(...args);
  },
  validate: (...args) => {
    stages.push('validate');
    return defaultHarness.validate(...args);
  },
  execute: (...args) => {
    stages.push('execute');
    return defaultHarness.execute(...args);
  },
  subscribe: (...args) => {
    stages.push('subscribe');
    return defaultHarness.subscribe(...args);
  },
};

const result = await graphql({
  schema,
  source: '{ greeting }',
  rootValue: { greeting: 'Hello' },
  rules: [],
  maxErrors: 25,
  hideSuggestions: true,
  noLocation: true,
  abortSignal: abortController.signal,
  harness,
});

result; // => { data: { greeting: 'Hello' } }
stages; // => ['parse', 'validate', 'execute']

Request Pipeline

function graphqlSync

graphqlSync: (args: GraphQLArgs) => ExecutionResult;

Parses, validates, and executes a GraphQL document synchronously.

This function guarantees that execution completes synchronously, or throws an error, assuming that all field resolvers are also synchronous. It throws when any resolver returns a promise.

Parameter args

Request execution arguments, including schema and source.

Returns

Completed execution output, or request errors if parsing or validation fails.

Example 1

// Execute a complete synchronous request with variables.
import { graphqlSync, buildSchema } from 'graphql';

const schema = buildSchema(`
  type Query {
    greeting(name: String!): String
  }
`);

const result = graphqlSync({
  schema,
  source: 'query SayHello($name: String!) { greeting(name: $name) }',
  rootValue: {
    greeting: ({ name }) => `Hello, ${name}!`,
  },
  variableValues: { name: 'Ada' },
  operationName: 'SayHello',
});

result; // => { data: { greeting: 'Hello, Ada!' } }

Example 2

// This variant uses a synchronous custom field resolver and context.
import { graphqlSync, buildSchema } from 'graphql';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);

const result = graphqlSync({
  schema,
  source: '{ greeting }',
  fieldResolver: (_source, _args, contextValue) => {
    return contextValue.defaultGreeting;
  },
  contextValue: { defaultGreeting: 'Hello' },
});

result; // => { data: { greeting: 'Hello' } }

Request Pipeline

function introspectionFromSchema

introspectionFromSchema: (
    schema: GraphQLSchema,
    options?: IntrospectionOptions
) => IntrospectionQuery;

Build an IntrospectionQuery from a GraphQLSchema

IntrospectionQuery is useful for utilities that care about type and field relationships, but do not need to traverse through those relationships.

This is the inverse of buildClientSchema. The primary use case is outside of the server context, for instance when doing schema comparisons.

Parameter schema

GraphQL schema to use.

Parameter options

Optional configuration for this operation.

Returns

Introspection result data for the schema.

Example 1

// Include schema metadata using the default introspection options.
import { buildSchema, introspectionFromSchema } from 'graphql/utilities';

const schema = buildSchema(`
  scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")

  type Query {
    homepage: Url
  }
`);

const introspection = introspectionFromSchema(schema);
const urlType = introspection.__schema.types.find(
  (type) => type.name === 'Url',
);

urlType.specifiedByURL; // => 'https://url.spec.whatwg.org/'

Example 2

// This variant disables optional introspection metadata.
import { buildSchema, introspectionFromSchema } from 'graphql/utilities';

const schema = buildSchema(`
  scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")

  type Query {
    homepage: Url
  }
`);

const introspection = introspectionFromSchema(schema, {
  descriptions: false,
  specifiedByUrl: false,
  directiveIsRepeatable: false,
  schemaDescription: false,
  inputValueDeprecation: false,
  experimentalDirectiveDeprecation: false,
  oneOf: false,
});
const urlType = introspection.__schema.types.find(
  (type) => type.name === 'Url',
);
const deprecatedDirective = introspection.__schema.directives.find(
  (directive) => directive.name === 'deprecated',
);

urlType.specifiedByURL; // => undefined
urlType.description; // => undefined
introspection.__schema.description; // => undefined
deprecatedDirective.isRepeatable; // => undefined

function isAbstractType

isAbstractType: (type: unknown) => type is GraphQLAbstractType;

Returns true when the value is a GraphQL interface or union type.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQL interface or union type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isAbstractType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  union SearchResult = User

  type Query {
    node: Node
    search: [SearchResult]
  }
`);

isAbstractType(schema.getType('Node')); // => true
isAbstractType(schema.getType('SearchResult')); // => true
isAbstractType(schema.getType('User')); // => false

function isArgument

isArgument: (arg: unknown) => arg is GraphQLArgument;

Returns true when the value is a resolved GraphQL argument definition.

Parameter arg

Value to inspect.

Returns

True when the value is a GraphQLArgument.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isArgument } from 'graphql/type';

const schema = buildSchema('type Query { greeting(name: String): String }');
const arg = schema.getQueryType().getFields().greeting.args[0];

isArgument(arg); // => true
isArgument(schema.getQueryType()); // => false

function isCompositeType

isCompositeType: (type: unknown) => type is GraphQLCompositeType;

Returns true when the value is a GraphQL object, interface, or union type.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQL object, interface, or union type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isCompositeType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  union SearchResult = User

  type Query {
    node: Node
    search: [SearchResult]
  }
`);

isCompositeType(schema.getType('User')); // => true
isCompositeType(schema.getType('Node')); // => true
isCompositeType(schema.getType('SearchResult')); // => true
isCompositeType(schema.getType('String')); // => false

function isConstValueNode

isConstValueNode: (node: ASTNode) => node is ConstValueNode;

Returns true when the AST node is a constant value node.

Parameter node

The AST node to test.

Returns

True when the AST node is a constant value node.

Example 1

import {
  parseConstValue,
  parseValue,
  isConstValueNode,
} from 'graphql/language';

const value = parseConstValue('[42]');
const variable = parseValue('$id');

isConstValueNode(value); // => true
isConstValueNode(variable); // => false

function isDefinitionNode

isDefinitionNode: (node: ASTNode) => node is DefinitionNode;

Returns true when the AST node is a definition node.

Parameter node

The AST node to test.

Returns

True when the AST node is a definition node.

Example 1

import { parse, isDefinitionNode } from 'graphql/language';

const document = parse('{ hello }');

isDefinitionNode(document.definitions[0]); // => true
isDefinitionNode(document); // => false

function isDevModeEnabled

isDevModeEnabled: () => boolean;

Returns whether GraphQL.js development mode has been enabled for this module instance.
Returns
True when development mode is enabled.
Example 1
import { enableDevMode, isDevModeEnabled } from 'graphql/devMode'; enableDevMode(); isDevModeEnabled(); // => true

function isDirective

isDirective: (directive: unknown) => directive is GraphQLDirective;

Test if the given value is a GraphQL directive.

Parameter directive

Value to inspect.

Returns

True when the value is a GraphQLDirective.

Example 1

import { DirectiveLocation } from 'graphql/language';
import { GraphQLDirective, GraphQLString, isDirective } from 'graphql/type';

const upper = new GraphQLDirective({
  name: 'upper',
  locations: [DirectiveLocation.FIELD_DEFINITION],
});

isDirective(upper); // => true
isDirective(GraphQLString); // => false

function isEnumType

isEnumType: (type: unknown) => type is GraphQLEnumType;

Returns true when the value is a GraphQLEnumType.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQLEnumType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isEnumType } from 'graphql/type';

const schema = buildSchema(`
  enum Episode {
    NEW_HOPE
    EMPIRE
  }

  type Query {
    favoriteEpisode: Episode
  }
`);

isEnumType(schema.getType('Episode')); // => true
isEnumType(schema.getType('Query')); // => false

function isEnumValue

isEnumValue: (value: unknown) => value is GraphQLEnumValue;

Returns true when the value is a resolved GraphQL enum value definition.

Parameter value

Value to inspect.

Returns

True when the value is a GraphQLEnumValue.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertEnumType, isEnumValue } from 'graphql/type';

const schema = buildSchema(
  'enum Episode { NEW_HOPE } type Query { episode: Episode }',
);
const enumValue = assertEnumType(schema.getType('Episode')).getValues()[0];

isEnumValue(enumValue); // => true
isEnumValue(schema.getType('Episode')); // => false

function isEqualType

isEqualType: (typeA: GraphQLType, typeB: GraphQLType) => boolean;

Provided two types, return true if the types are equal (invariant).

Parameter typeA

The first GraphQL type to compare.

Parameter typeB

The second GraphQL type to compare.

Returns

True when both types are equal.

Example 1

import { GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql/type';
import { isEqualType } from 'graphql/utilities';

isEqualType(GraphQLString, GraphQLString); // => true
isEqualType(new GraphQLList(GraphQLString), new GraphQLList(GraphQLString)); // => true
isEqualType(new GraphQLNonNull(GraphQLString), GraphQLString); // => false

function isExecutableDefinitionNode

isExecutableDefinitionNode: (node: ASTNode) => node is ExecutableDefinitionNode;

Returns true when the AST node is an executable definition node.

Parameter node

The AST node to test.

Returns

True when the AST node is an executable definition node.

Example 1

import { parse, isExecutableDefinitionNode } from 'graphql/language';

const query = parse('{ hello }');
const schema = parse('type Query { hello: String }');

isExecutableDefinitionNode(query.definitions[0]); // => true
isExecutableDefinitionNode(schema.definitions[0]); // => false

function isField

isField: (field: unknown) => field is GraphQLField<any, any, any>;

Returns true when the value is a resolved GraphQL field definition.

Parameter field

Value to inspect.

Returns

True when the value is a GraphQLField.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isField } from 'graphql/type';

const schema = buildSchema('type Query { greeting: String }');
const field = schema.getQueryType().getFields().greeting;

isField(field); // => true
isField(schema.getQueryType()); // => false

function isInputField

isInputField: (field: unknown) => field is GraphQLInputField;

Returns true when the value is a resolved GraphQL input field definition.

Parameter field

Value to inspect.

Returns

True when the value is a GraphQLInputField.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInputObjectType, isInputField } from 'graphql/type';

const schema = buildSchema(
  'input ReviewInput { stars: Int } type Query { ok: Boolean }',
);
const inputField = assertInputObjectType(
  schema.getType('ReviewInput'),
).getFields().stars;

isInputField(inputField); // => true
isInputField(schema.getQueryType()); // => false

function isInputObjectType

isInputObjectType: (type: unknown) => type is GraphQLInputObjectType;

Returns true when the value is a GraphQLInputObjectType.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQLInputObjectType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isInputObjectType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type Review {
    stars: Int!
  }

  type Query {
    review(input: ReviewInput): Review
  }
`);

isInputObjectType(schema.getType('ReviewInput')); // => true
isInputObjectType(schema.getType('Review')); // => false

function isInputType

isInputType: (type: unknown) => type is GraphQLInputType;

Returns true when the value can be used as a GraphQL input type.

Parameter type

The GraphQL type to inspect.

Returns

True when the value can be used as a GraphQL input type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isInputType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type Review {
    stars: Int!
  }

  type Query {
    review(input: ReviewInput): Review
  }
`);

isInputType(schema.getType('ReviewInput')); // => true
isInputType(schema.getType('Review')); // => false

function isInterfaceType

isInterfaceType: (type: unknown) => type is GraphQLInterfaceType<any, any>;

Returns true when the value is a GraphQLInterfaceType.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQLInterfaceType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isInterfaceType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Query {
    node: Node
  }
`);

isInterfaceType(schema.getType('Node')); // => true
isInterfaceType(schema.getType('User')); // => false

function isIntrospectionType

isIntrospectionType: (type: GraphQLNamedType) => boolean;

Returns true when the type is one of the built-in introspection types.
Parameter type
The GraphQL type to inspect.
Returns
True when the type is one of the built-in introspection types.
Example 1
import { GraphQLString, isIntrospectionType, __Type } from 'graphql/type'; isIntrospectionType(__Type); // => true isIntrospectionType(GraphQLString); // => false

function isLeafType

isLeafType: (type: unknown) => type is GraphQLLeafType;

Returns true when the value is a GraphQL scalar or enum type.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQL scalar or enum type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isLeafType } from 'graphql/type';

const schema = buildSchema(`
  enum Episode {
    NEW_HOPE
  }

  type Review {
    stars: Int!
  }

  type Query {
    episode: Episode
    review: Review
  }
`);

isLeafType(schema.getType('Episode')); // => true
isLeafType(schema.getType('String')); // => true
isLeafType(schema.getType('Review')); // => false

function isListType

isListType: {
    (type: GraphQLInputType): type is GraphQLList<GraphQLInputType>;
    (type: GraphQLOutputType): type is GraphQLList<GraphQLOutputType>;
    (type: unknown): type is GraphQLList<GraphQLType>;
};

Returns true when the value is a GraphQLList.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQLList.

Example 1

import { buildSchema } from 'graphql/utilities';
import { GraphQLList, GraphQLString, isListType } from 'graphql/type';

const schema = buildSchema(`
  type Query {
    tags: [String!]!
  }
`);

const tagsField = schema.getQueryType()?.getFields().tags;

isListType(new GraphQLList(GraphQLString)); // => true
isListType(GraphQLString); // => false
isListType(tagsField?.type); // => false

Returns true when the output type is a GraphQLList.

Parameter type

The GraphQL output type to inspect.

Returns

True when the output type is a list type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { getNullableType, isListType } from 'graphql/type';

const schema = buildSchema(`
  type Query {
    tags: [String!]!
  }
`);

const tagsField = schema.getQueryType()?.getFields().tags;
const nullableTagsType = getNullableType(tagsField?.type);

isListType(nullableTagsType); // => true

Returns true when the value is a GraphQLList.
Parameter type
The value to inspect.
Returns
True when the value is a list type.
Example 1
import { isListType } from 'graphql/type'; isListType('[String]'); // => false isListType(null); // => false

function isNamedType

isNamedType: (type: unknown) => type is GraphQLNamedType;

Returns true when the value is a GraphQL named type.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQL named type.

Example 1

import { GraphQLList, GraphQLString, isNamedType } from 'graphql/type';

isNamedType(GraphQLString); // => true
isNamedType(new GraphQLList(GraphQLString)); // => false
isNamedType(null); // => false

function isNonNullType

isNonNullType: {
    (type: GraphQLInputType): type is GraphQLNonNull<GraphQLNullableInputType>;
    (type: GraphQLOutputType): type is GraphQLNonNull<GraphQLNullableOutputType>;
    (type: unknown): type is GraphQLNonNull<GraphQLNullableType>;
};

Returns true when the value is a GraphQLNonNull.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQLNonNull.

Example 1

import { buildSchema } from 'graphql/utilities';
import { GraphQLNonNull, GraphQLString, isNonNullType } from 'graphql/type';

const schema = buildSchema(`
  type Query {
    name: String!
    nickname: String
  }
`);

const fields = schema.getQueryType()?.getFields();

isNonNullType(new GraphQLNonNull(GraphQLString)); // => true
isNonNullType(fields?.name.type); // => true
isNonNullType(fields?.nickname.type); // => false

Returns true when the output type is a GraphQLNonNull.

Parameter type

The GraphQL output type to inspect.

Returns

True when the output type is a non-null type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isNonNullType } from 'graphql/type';

const schema = buildSchema(`
  type Query {
    name: String!
    nickname: String
  }
`);

const fields = schema.getQueryType()?.getFields();

isNonNullType(fields?.name.type); // => true
isNonNullType(fields?.nickname.type); // => false

Returns true when the value is a GraphQLNonNull.
Parameter type
The value to inspect.
Returns
True when the value is a non-null type.
Example 1
import { isNonNullType } from 'graphql/type'; isNonNullType('String!'); // => false isNonNullType(null); // => false

function isNullableType

isNullableType: (type: unknown) => type is GraphQLNullableType;

Returns true when the value is a GraphQL type that can accept null.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQL type that can accept null.

Example 1

import { GraphQLNonNull, GraphQLString, isNullableType } from 'graphql/type';

isNullableType(GraphQLString); // => true
isNullableType(new GraphQLNonNull(GraphQLString)); // => false
isNullableType(null); // => false

function isObjectType

isObjectType: (type: unknown) => type is GraphQLObjectType<any, any, any>;

Returns true when the value is a GraphQLObjectType.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQLObjectType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isObjectType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type User {
    name: String
  }

  type Query {
    user: User
  }
`);

isObjectType(schema.getType('User')); // => true
isObjectType(schema.getType('ReviewInput')); // => false

function isOutputType

isOutputType: (type: unknown) => type is GraphQLOutputType;

Returns true when the value can be used as a GraphQL output type.

Parameter type

The GraphQL type to inspect.

Returns

True when the value can be used as a GraphQL output type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isOutputType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type Review {
    stars: Int!
  }

  type Query {
    review(input: ReviewInput): Review
  }
`);

isOutputType(schema.getType('Review')); // => true
isOutputType(schema.getType('ReviewInput')); // => false

function isRequiredArgument

isRequiredArgument: (arg: GraphQLArgument | GraphQLVariableSignature) => boolean;

Returns true when the argument is non-null and has no default value.

Parameter arg

The argument definition to inspect.

Returns

True when the argument is non-null and has no default value.

Example 1

import {
  GraphQLArgument,
  GraphQLField,
  GraphQLInt,
  GraphQLNonNull,
  GraphQLObjectType,
  GraphQLString,
  isRequiredArgument,
} from 'graphql/type';

const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
const field = new GraphQLField(Query, 'reviews', { type: GraphQLString });
const requiredArgument = new GraphQLArgument(field, 'id', {
  type: new GraphQLNonNull(GraphQLInt),
});
const optionalArgument = new GraphQLArgument(field, 'name', {
  type: GraphQLString,
});
const argumentWithDefault = new GraphQLArgument(field, 'limit', {
  type: new GraphQLNonNull(GraphQLInt),
  default: { value: 10 },
});

isRequiredArgument(requiredArgument); // => true
isRequiredArgument(optionalArgument); // => false
isRequiredArgument(argumentWithDefault); // => false

function isRequiredInputField

isRequiredInputField: (field: GraphQLInputField) => boolean;

Returns true when the input field is non-null and has no default value.

Parameter field

The input field definition to inspect.

Returns

True when the input field is non-null and has no default value.

Example 1

import {
  GraphQLInputField,
  GraphQLInputObjectType,
  GraphQLInt,
  GraphQLNonNull,
  GraphQLString,
  isRequiredInputField,
} from 'graphql/type';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {},
});
const requiredField = new GraphQLInputField(ReviewInput, 'id', {
  type: new GraphQLNonNull(GraphQLInt),
});
const optionalField = new GraphQLInputField(ReviewInput, 'name', {
  type: GraphQLString,
});
const fieldWithDefault = new GraphQLInputField(ReviewInput, 'limit', {
  type: new GraphQLNonNull(GraphQLInt),
  default: { value: 10 },
});

isRequiredInputField(requiredField); // => true
isRequiredInputField(optionalField); // => false
isRequiredInputField(fieldWithDefault); // => false

function isScalarType

isScalarType: (type: unknown) => type is GraphQLScalarType<unknown, unknown>;

There are predicates for each kind of GraphQL type.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQLScalarType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isScalarType } from 'graphql/type';

const schema = buildSchema(`
  scalar DateTime

  type Query {
    createdAt: DateTime
  }
`);

isScalarType(schema.getType('DateTime')); // => true
isScalarType(schema.getType('Query')); // => false

function isSchema

isSchema: (schema: unknown) => schema is GraphQLSchema;

Test if the given value is a GraphQL schema.

Parameter schema

Value to inspect.

Returns

True when the value is a GraphQLSchema.

Example 1

import { buildSchema } from 'graphql/utilities';
import { GraphQLString, isSchema } from 'graphql/type';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);

isSchema(schema); // => true
isSchema(GraphQLString); // => false

function isSchemaCoordinateNode

isSchemaCoordinateNode: (node: ASTNode) => node is SchemaCoordinateNode;

Returns true when the AST node is a schema coordinate node.

Parameter node

The AST node to test.

Returns

True when the AST node is a schema coordinate node.

Example 1

import {
  parse,
  parseSchemaCoordinate,
  isSchemaCoordinateNode,
} from 'graphql/language';

const coordinate = parseSchemaCoordinate('Query.hero');
const document = parse('{ hero }');

isSchemaCoordinateNode(coordinate); // => true
isSchemaCoordinateNode(document); // => false

function isSelectionNode

isSelectionNode: (node: ASTNode) => node is SelectionNode;

Returns true when the AST node is a selection node.

Parameter node

The AST node to test.

Returns

True when the AST node is a selection node.

Example 1

import { Kind, isSelectionNode } from 'graphql/language';

const field = { kind: Kind.FIELD, name: { kind: Kind.NAME, value: 'hello' } };
const document = { kind: Kind.DOCUMENT, definitions: [] };

isSelectionNode(field); // => true
isSelectionNode(document); // => false

function isSpecifiedDirective

isSpecifiedDirective: (directive: GraphQLDirective) => boolean;

Returns true when the directive is one of the directives specified by GraphQL.

Parameter directive

Directive to inspect.

Returns

True when the directive is specified by GraphQL.

Example 1

import {
  GraphQLDirective,
  GraphQLIncludeDirective,
  isSpecifiedDirective,
} from 'graphql/type';
import { DirectiveLocation } from 'graphql/language';

const customDirective = new GraphQLDirective({
  name: 'auth',
  locations: [DirectiveLocation.FIELD_DEFINITION],
});

isSpecifiedDirective(GraphQLIncludeDirective); // => true
isSpecifiedDirective(customDirective); // => false

function isSpecifiedScalarType

isSpecifiedScalarType: (type: GraphQLNamedType) => boolean;

Returns true when the scalar type is one of the scalars specified by GraphQL.

Parameter type

The GraphQL type to inspect.

Returns

True when the scalar type is one of the scalars specified by GraphQL.

Example 1

import {
  GraphQLScalarType,
  GraphQLString,
  isSpecifiedScalarType,
} from 'graphql/type';

const DateTime = new GraphQLScalarType({
  name: 'DateTime',
});

isSpecifiedScalarType(GraphQLString); // => true
isSpecifiedScalarType(DateTime); // => false

function isSubscriptionOperationDefinitionNode

isSubscriptionOperationDefinitionNode: (
    node: OperationDefinitionNode
) => node is SubscriptionOperationDefinitionNode;

A type predicate for SubscriptionOperationDefinitionNode. Useful anywhere that must distinguish subscription operations from queries and mutations, such as the subscription execution pipeline which routes events through a different code path.
Parameter node
Operation definition node to test.
Returns
True when the operation definition is a subscription.
Example 1
import { parse, isSubscriptionOperationDefinitionNode } from 'graphql/language'; const subscription = parse('subscription { greeting }').definitions[0]; const query = parse('{ greeting }').definitions[0]; isSubscriptionOperationDefinitionNode(subscription); // => true isSubscriptionOperationDefinitionNode(query); // => false

function isType

isType: (type: unknown) => type is GraphQLType;

Returns true when the value is any GraphQL type.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is any GraphQL type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { GraphQLList, GraphQLString, isType } from 'graphql/type';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

isType(GraphQLString); // => true
isType(new GraphQLList(GraphQLString)); // => true
isType(schema.getType('Query')); // => true
isType('String'); // => false

function isTypeDefinitionNode

isTypeDefinitionNode: (node: ASTNode) => node is TypeDefinitionNode;

Returns true when the AST node is a type definition node.

Parameter node

The AST node to test.

Returns

True when the AST node is a type definition node.

Example 1

import { parse, isTypeDefinitionNode } from 'graphql/language';

const typeDefinition = parse('type Query { hello: String }');
const directiveDefinition = parse('directive @cache on FIELD');

isTypeDefinitionNode(typeDefinition.definitions[0]); // => true
isTypeDefinitionNode(directiveDefinition.definitions[0]); // => false

function isTypeExtensionNode

isTypeExtensionNode: (node: ASTNode) => node is TypeExtensionNode;

Returns true when the AST node is a type extension node.

Parameter node

The AST node to test.

Returns

True when the AST node is a type extension node.

Example 1

import { parse, isTypeExtensionNode } from 'graphql/language';

const extension = parse('extend type Query { hello: String }');
const schemaExtension = parse('extend schema { query: Query }');

isTypeExtensionNode(extension.definitions[0]); // => true
isTypeExtensionNode(schemaExtension.definitions[0]); // => false

function isTypeNode

isTypeNode: (node: ASTNode) => node is TypeNode;

Returns true when the AST node is a type node.

Parameter node

The AST node to test.

Returns

True when the AST node is a type node.

Example 1

import { parseType, parseValue, isTypeNode } from 'graphql/language';

const type = parseType('[String!]');
const value = parseValue('[42]');

isTypeNode(type); // => true
isTypeNode(value); // => false

function isTypeSubTypeOf

isTypeSubTypeOf: (
    schema: GraphQLSchema,
    maybeSubType: GraphQLType,
    superType: GraphQLType
) => boolean;

Provided a type and a super type, return true if the first type is either equal or a subset of the second super type (covariant).

Parameter schema

GraphQL schema to use.

Parameter maybeSubType

The possible subtype to compare.

Parameter superType

The possible supertype to compare.

Returns

True when maybeSubType is equal to or a subtype of superType.

Example 1

import { buildSchema } from 'graphql/utilities';
import {
  GraphQLNonNull,
  assertInterfaceType,
  assertObjectType,
} from 'graphql/type';
import { isTypeSubTypeOf } from 'graphql/utilities';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Query {
    node: Node
  }
`);
const Node = assertInterfaceType(schema.getType('Node'));
const User = assertObjectType(schema.getType('User'));

isTypeSubTypeOf(schema, User, Node); // => true
isTypeSubTypeOf(schema, new GraphQLNonNull(User), Node); // => true
isTypeSubTypeOf(schema, Node, User); // => false

function isTypeSystemDefinitionNode

isTypeSystemDefinitionNode: (node: ASTNode) => node is TypeSystemDefinitionNode;

Returns true when the AST node is a type system definition node.

Parameter node

The AST node to test.

Returns

True when the AST node is a type system definition node.

Example 1

import { parse, isTypeSystemDefinitionNode } from 'graphql/language';

const schema = parse('type Query { hello: String }');
const query = parse('{ hello }');

isTypeSystemDefinitionNode(schema.definitions[0]); // => true
isTypeSystemDefinitionNode(query.definitions[0]); // => false

function isTypeSystemExtensionNode

isTypeSystemExtensionNode: (node: ASTNode) => node is TypeSystemExtensionNode;

Returns true when the AST node is a type system extension node.

Parameter node

The AST node to test.

Returns

True when the AST node is a type system extension node.

Example 1

import { parse, isTypeSystemExtensionNode } from 'graphql/language';

const extension = parse('extend type Query { hello: String }');
const definition = parse('type Query { hello: String }');

isTypeSystemExtensionNode(extension.definitions[0]); // => true
isTypeSystemExtensionNode(definition.definitions[0]); // => false

function isUnionType

isUnionType: (type: unknown) => type is GraphQLUnionType<any, any>;

Returns true when the value is a GraphQLUnionType.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQLUnionType.

Example 1

import { buildSchema } from 'graphql/utilities';
import { isUnionType } from 'graphql/type';

const schema = buildSchema(`
  type Photo {
    url: String!
  }

  type Video {
    url: String!
  }

  union Media = Photo | Video

  type Query {
    media: [Media]
  }
`);

isUnionType(schema.getType('Media')); // => true
isUnionType(schema.getType('Photo')); // => false

function isValueNode

isValueNode: (node: ASTNode) => node is ValueNode;

Returns true when the AST node is a value node.

Parameter node

The AST node to test.

Returns

True when the AST node is a value node.

Example 1

import { parseType, parseValue, isValueNode } from 'graphql/language';

const value = parseValue('[42]');
const type = parseType('[String!]');

isValueNode(value); // => true
isValueNode(type); // => false

function isWrappingType

isWrappingType: (type: unknown) => type is GraphQLWrappingType;

Returns true when the value is a GraphQL list or non-null wrapper type.

Parameter type

The GraphQL type to inspect.

Returns

True when the value is a GraphQL list or non-null wrapper type.

Example 1

import {
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
  isWrappingType,
} from 'graphql/type';

isWrappingType(new GraphQLList(GraphQLString)); // => true
isWrappingType(new GraphQLNonNull(GraphQLString)); // => true
isWrappingType(GraphQLString); // => false

function KnownArgumentNamesRule

KnownArgumentNamesRule: (context: ValidationContext) => ASTVisitor;

Known argument names

A GraphQL field is only valid if all supplied arguments are defined by that field.

See https://spec.graphql.org/draft/#sec-Argument-Names See https://spec.graphql.org/draft/#sec-Directives-Are-In-Valid-Locations

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { KnownArgumentNamesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    field(arg: String): String
  }
`);

const invalidDocument = parse(`
  { field(unknown: "1") }
`);
const invalidErrors = validate(schema, invalidDocument, [
  KnownArgumentNamesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { field(arg: "1") }
`);
const validErrors = validate(schema, validDocument, [KnownArgumentNamesRule]);

validErrors; // => []

function KnownDirectivesRule

KnownDirectivesRule: (
    context: ValidationContext | SDLValidationContext
) => ASTVisitor;

Known directives

A GraphQL document is only valid if all @directives are known by the schema and legally positioned.

See https://spec.graphql.org/draft/#sec-Directives-Are-Defined

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { KnownDirectivesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  { name @unknown }
`);
const invalidErrors = validate(schema, invalidDocument, [KnownDirectivesRule]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { name @include(if: true) }
`);
const validErrors = validate(schema, validDocument, [KnownDirectivesRule]);

validErrors; // => []

function KnownFragmentNamesRule

KnownFragmentNamesRule: (context: ValidationContext) => ASTVisitor;

Known fragment names

A GraphQL document is only valid if all ...Fragment fragment spreads refer to fragments defined in the same document.

See https://spec.graphql.org/draft/#sec-Fragment-spread-target-defined

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { KnownFragmentNamesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  { ...Missing }
`);
const invalidErrors = validate(schema, invalidDocument, [
  KnownFragmentNamesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  fragment NameFields on Query { name } query { ...NameFields }
`);
const validErrors = validate(schema, validDocument, [KnownFragmentNamesRule]);

validErrors; // => []

function KnownOperationTypesRule

KnownOperationTypesRule: (context: ValidationContext) => ASTVisitor;

Known Operation Types

A GraphQL document is only valid if when it contains an operation, the root type for the operation exists within the schema.

See https://spec.graphql.org/draft/#sec-Operation-Type-Existence

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { validate, KnownOperationTypesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const invalidDocument = parse('mutation { greeting }');
const validDocument = parse('{ greeting }');

validate(schema, invalidDocument, [KnownOperationTypesRule])[0].message; // => 'The mutation operation is not supported by the schema.'
validate(schema, validDocument, [KnownOperationTypesRule]); // => []

function KnownTypeNamesRule

KnownTypeNamesRule: (
    context: ValidationContext | SDLValidationContext
) => ASTVisitor;

Known type names

A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.

See https://spec.graphql.org/draft/#sec-Fragment-Spread-Type-Existence

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { KnownTypeNamesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  fragment Bad on Missing { name }
`);
const invalidErrors = validate(schema, invalidDocument, [KnownTypeNamesRule]);

invalidErrors.length; // => 1

const validDocument = parse(`
  fragment Good on Query { name }
`);
const validErrors = validate(schema, validDocument, [KnownTypeNamesRule]);

validErrors; // => []

function legacyExecuteIncrementally

legacyExecuteIncrementally: (
    args: ExecutionArgs
) => PromiseOrValue<ExecutionResult | LegacyExperimentalIncrementalExecutionResults>;

Executes a GraphQL operation with support for @defer and @stream using the legacy incremental delivery payload format.

Prefer experimentalExecuteIncrementally for the current incremental delivery format. In the legacy format, each subsequent incremental payload identifies its location with path and optional label fields. The current format instead tracks pending work by id and reports completion through completed entries.

Parameter args

Execution arguments for the GraphQL operation.

Returns

A single execution result or legacy incremental execution results.

Example 1

import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { legacyExecuteIncrementally } from 'graphql/execution';

const schema = buildSchema(`
  type Query {
    hero: Hero
  }

  type Hero {
    id: ID!
    name: String!
  }
`);

const result = await legacyExecuteIncrementally({
  schema,
  document: parse('{ hero { id ... @defer(label: "HeroName") { name } } }'),
  rootValue: { hero: { id: '1', name: 'Luke' } },
});

assert('initialResult' in result);

result.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }

const deferred = await result.subsequentResults.next();
deferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'], label: 'HeroName' } ], hasNext: false }

Example 2

Compare the legacy payload format with the current incremental delivery format returned by experimentalExecuteIncrementally.

import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import {
  experimentalExecuteIncrementally,
  legacyExecuteIncrementally,
} from 'graphql/execution';

const schema = buildSchema(`
  type Query {
    hero: Hero
  }

  type Hero {
    id: ID!
    name: String!
  }
`);
const document = parse('{ hero { id ... @defer { name } } }');
const rootValue = { hero: { id: '1', name: 'Luke' } };

const experimental = await experimentalExecuteIncrementally({
  schema,
  document,
  rootValue,
});
const legacy = await legacyExecuteIncrementally({
  schema,
  document,
  rootValue,
});

assert('initialResult' in experimental);
assert('initialResult' in legacy);

experimental.initialResult; // => { data: { hero: { id: '1' } }, pending: [ { id: '0', path: ['hero'] } ], hasNext: true }
legacy.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }

const experimentalDeferred = await experimental.subsequentResults.next();
experimentalDeferred.value; // => { incremental: [{ data: { name: 'Luke' }, id: '0' }], completed: [{ id: '0' }], hasNext: false }

const legacyDeferred = await legacy.subsequentResults.next();
legacyDeferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'] } ], hasNext: false }

Example 3

Compare streamed list payloads in the legacy and current incremental delivery formats.

import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import {
  experimentalExecuteIncrementally,
  legacyExecuteIncrementally,
} from 'graphql/execution';

const schema = buildSchema('type Query { colors: [String] }');
const document = parse('{ colors @stream(initialCount: 1) }');
const rootValue = { colors: ['red', 'green', 'blue'] };

const experimental = await experimentalExecuteIncrementally({
  schema,
  document,
  rootValue,
});
const legacy = await legacyExecuteIncrementally({
  schema,
  document,
  rootValue,
});

assert('initialResult' in experimental);
assert('initialResult' in legacy);

experimental.initialResult; // => { data: { colors: ['red'] }, pending: [ { id: '0', path: ['colors'] } ], hasNext: true }
legacy.initialResult; // => { data: { colors: ['red'] }, hasNext: true }

const experimentalStream = await experimental.subsequentResults.next();
experimentalStream.value; // => { incremental: [ { items: ['green', 'blue'], id: '0' } ], completed: [{ id: '0' }], hasNext: false }

const legacyStream = await legacy.subsequentResults.next();
legacyStream.value; // => { incremental: [ { items: ['green', 'blue'], path: ['colors', 1] } ], hasNext: false }

function legacyExecuteRootSelectionSet

legacyExecuteRootSelectionSet: (
    validatedExecutionArgs: ValidatedExecutionArgs
) => PromiseOrValue<ExecutionResult | LegacyExperimentalIncrementalExecutionResults>;

Executes a validated operation root selection set with support for @defer and @stream using the legacy incremental delivery payload format.

Parameter validatedExecutionArgs

Validated execution arguments.

Returns

A single execution result or legacy incremental execution results.

Example 1

import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import {
  legacyExecuteRootSelectionSet,
  validateExecutionArgs,
} from 'graphql/execution';

const schema = buildSchema('type Query { greeting: String }');
const validatedArgs = validateExecutionArgs({
  schema,
  document: parse('{ greeting }'),
  rootValue: { greeting: 'Hello' },
});

assert('schema' in validatedArgs);

const result = await legacyExecuteRootSelectionSet(validatedArgs);
result; // => { data: { greeting: 'Hello' } }

function lexicographicSortSchema

lexicographicSortSchema: (schema: GraphQLSchema) => GraphQLSchema;

Sort GraphQLSchema.

This function returns a sorted copy of the given GraphQLSchema.

Parameter schema

GraphQL schema to use.

Returns

A copy of the schema with types, fields, arguments, and values sorted lexicographically.

Example 1

import {
  buildSchema,
  lexicographicSortSchema,
  printSchema,
} from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    zebra: String
    apple: String
  }

  enum Episode {
    JEDI
    NEW_HOPE
    EMPIRE
  }
`);

const sortedSchema = lexicographicSortSchema(schema);

printSchema(sortedSchema);
// =>
// enum Episode {
//   EMPIRE
//   JEDI
//   NEW_HOPE
// }
//
// type Query {
//   apple: String
//   zebra: String
// }

function locatedError

locatedError: (
    rawOriginalError: unknown,
    nodes: ASTNode | ReadonlyArray<ASTNode> | undefined | null,
    path?: Maybe<ReadonlyArray<string | number>>
) => GraphQLError;

Given an arbitrary value, presumably thrown while attempting to execute a GraphQL operation, produce a new GraphQLError aware of the location in the document responsible for the original Error.

Parameter rawOriginalError

The original error value to wrap.

Parameter nodes

The AST nodes associated with the error.

Parameter path

The response path associated with the error.

Returns

The GraphQL error.

Example 1

import { parse } from 'graphql/language';
import { locatedError } from 'graphql/error';

const document = parse('{ viewer { name } }');
const fieldNode = document.definitions[0].selectionSet.selections[0];
const error = locatedError(new Error('Resolver failed'), fieldNode, ['viewer']);

error.message; // => 'Resolver failed'
error.locations; // => [{ line: 1, column: 3 }]
error.path; // => ['viewer']

function LoneAnonymousOperationRule

LoneAnonymousOperationRule: (context: ASTValidationContext) => ASTVisitor;

Lone anonymous operation

A GraphQL document is only valid if when it contains an anonymous operation (the query short-hand) that it contains only that one operation definition.

See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { LoneAnonymousOperationRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  query { name } query Other { name }
`);
const invalidErrors = validate(schema, invalidDocument, [
  LoneAnonymousOperationRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { name }
`);
const validErrors = validate(schema, validDocument, [
  LoneAnonymousOperationRule,
]);

validErrors; // => []

function LoneSchemaDefinitionRule

LoneSchemaDefinitionRule: (context: SDLValidationContext) => ASTVisitor;

Lone Schema definition

A GraphQL document is only valid if it contains only one schema definition.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema } from 'graphql';
import { LoneSchemaDefinitionRule } from 'graphql/validation';

const invalidSDL = `
  schema { query: Query } schema { query: Query } type Query { name: String }
`;

LoneSchemaDefinitionRule.name; // => 'LoneSchemaDefinitionRule'
buildSchema(invalidSDL); // throws an error

const validSDL = `
  schema { query: Query } type Query { name: String }
`;

buildSchema(validSDL); // does not throw

function mapSourceToResponseEvent

mapSourceToResponseEvent: (
    validatedExecutionArgs: ValidatedSubscriptionArgs,
    sourceEventStream: AsyncIterable<unknown>,
    rootSelectionSetExecutor?: RootSelectionSetExecutor
) => AsyncGenerator<ExecutionResult, void, void>;

Implements the "MapSourceToResponseEvent" algorithm described in the GraphQL specification, mapping each event from a subscription source event stream to an ExecutionResult in the response stream.

Parameter validatedExecutionArgs

Validated subscription execution arguments.

Parameter sourceEventStream

Source event stream returned by the subscription resolver.

Parameter rootSelectionSetExecutor

Function used to execute each source event.

Returns

A response stream of execution results.

Example 1

import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import {
  mapSourceToResponseEvent,
  validateSubscriptionArgs,
} from 'graphql/execution';

async function* events() {
  yield { greeting: 'Hello' };
}

const schema = buildSchema(`
  type Query {
    noop: String
  }

  type Subscription {
    greeting: String
  }
`);
const validatedArgs = validateSubscriptionArgs({
  schema,
  document: parse('subscription { greeting }'),
});

assert('schema' in validatedArgs);

const responseStream = mapSourceToResponseEvent(validatedArgs, events());
const firstPayload = await responseStream.next();

firstPayload.value; // => { data: { greeting: 'Hello' } }

function MaxIntrospectionDepthRule

MaxIntrospectionDepthRule: (context: ASTValidationContext) => ASTVisitor;

Implements the max introspection depth validation rule.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { MaxIntrospectionDepthRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  { __schema { types { fields { type { fields { type { fields { name } } } } } } } }
`);
const invalidErrors = validate(schema, invalidDocument, [
  MaxIntrospectionDepthRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { __schema { queryType { name } } }
`);
const validErrors = validate(schema, validDocument, [
  MaxIntrospectionDepthRule,
]);

validErrors; // => []

function NoDeprecatedCustomRule

NoDeprecatedCustomRule: (context: ValidationContext) => ASTVisitor;

No deprecated

A GraphQL document is only valid if all selected fields and all used enum values have not been deprecated.

Note: This rule is optional and is not part of the Validation section of the GraphQL Specification. The main purpose of this rule is detection of deprecated usages and not necessarily to forbid their use when querying a service.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import {
  GraphQLObjectType,
  GraphQLSchema,
  GraphQLString,
  parse,
  validate,
} from 'graphql';
import { NoDeprecatedCustomRule } from 'graphql/validation';

const schema = new GraphQLSchema({
  query: new GraphQLObjectType({
    name: 'Query',
    fields: {
      name: { type: GraphQLString },
      oldName: {
        type: GraphQLString,
        deprecationReason: 'Use name instead.',
      },
    },
  }),
});

const invalidDocument = parse(`
  { oldName }
`);
const invalidErrors = validate(schema, invalidDocument, [
  NoDeprecatedCustomRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { name }
`);
const validErrors = validate(schema, validDocument, [NoDeprecatedCustomRule]);

validErrors; // => []

function NoFragmentCyclesRule

NoFragmentCyclesRule: (context: ASTValidationContext) => ASTVisitor;

No fragment cycles

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.

See https://spec.graphql.org/draft/#sec-Fragment-spreads-must-not-form-cycles

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { NoFragmentCyclesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  fragment A on Query { ...B } fragment B on Query { ...A } query { ...A }
`);
const invalidErrors = validate(schema, invalidDocument, [NoFragmentCyclesRule]);

invalidErrors.length; // => 1

const validDocument = parse(`
  fragment A on Query { name } query { ...A }
`);
const validErrors = validate(schema, validDocument, [NoFragmentCyclesRule]);

validErrors; // => []

function NoSchemaIntrospectionCustomRule

NoSchemaIntrospectionCustomRule: (context: ValidationContext) => ASTVisitor;

Prohibit introspection queries

A GraphQL document is only valid if all fields selected are not fields that return an introspection type.

Note: This rule is optional and is not part of the Validation section of the GraphQL Specification. This rule effectively disables introspection, which does not reflect best practices and should only be done if absolutely necessary.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { NoSchemaIntrospectionCustomRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  { __schema { queryType { name } } }
`);
const invalidErrors = validate(schema, invalidDocument, [
  NoSchemaIntrospectionCustomRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { name }
`);
const validErrors = validate(schema, validDocument, [
  NoSchemaIntrospectionCustomRule,
]);

validErrors; // => []

function NoUndefinedVariablesRule

NoUndefinedVariablesRule: (context: ValidationContext) => ASTVisitor;

No undefined variables

A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.

See https://spec.graphql.org/draft/#sec-All-Variable-Uses-Defined

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { NoUndefinedVariablesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    field(arg: ID): String
  }
`);

const invalidDocument = parse(`
  query ($id: ID) { field(arg: $missing) }
`);
const invalidErrors = validate(schema, invalidDocument, [
  NoUndefinedVariablesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  query ($id: ID) { field(arg: $id) }
`);
const validErrors = validate(schema, validDocument, [NoUndefinedVariablesRule]);

validErrors; // => []

function NoUnusedFragmentsRule

NoUnusedFragmentsRule: (context: ASTValidationContext) => ASTVisitor;

No unused fragments

A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.

See https://spec.graphql.org/draft/#sec-Fragments-Must-Be-Used

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { NoUnusedFragmentsRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  fragment Unused on Query { name } query { name }
`);
const invalidErrors = validate(schema, invalidDocument, [
  NoUnusedFragmentsRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  fragment Used on Query { name } query { ...Used }
`);
const validErrors = validate(schema, validDocument, [NoUnusedFragmentsRule]);

validErrors; // => []

function NoUnusedVariablesRule

NoUnusedVariablesRule: (context: ValidationContext) => ASTVisitor;

No unused variables

A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.

See https://spec.graphql.org/draft/#sec-All-Variables-Used

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { NoUnusedVariablesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    field(arg: ID): String
    name: String
  }
`);

const invalidDocument = parse(`
  query ($id: ID) { name }
`);
const invalidErrors = validate(schema, invalidDocument, [
  NoUnusedVariablesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  query ($id: ID) { field(arg: $id) }
`);
const validErrors = validate(schema, validDocument, [NoUnusedVariablesRule]);

validErrors; // => []

function OverlappingFieldsCanBeMergedRule

OverlappingFieldsCanBeMergedRule: (context: ValidationContext) => ASTVisitor;

Overlapping fields can be merged

A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.

See https://spec.graphql.org/draft/#sec-Field-Selection-Merging

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { OverlappingFieldsCanBeMergedRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    dog: Dog
  }

  type Dog {
    name: String
    barkVolume: Int
  }
`);

const invalidDocument = parse(`
  { dog { value: barkVolume value: name } }
`);
const invalidErrors = validate(schema, invalidDocument, [
  OverlappingFieldsCanBeMergedRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { dog { barkVolume name } }
`);
const validErrors = validate(schema, validDocument, [
  OverlappingFieldsCanBeMergedRule,
]);

validErrors; // => []

function parse

parse: (source: string | Source, options?: ParseOptions) => DocumentNode;

Given a GraphQL source, parses it into a Document. Throws GraphQLError if a syntax error is encountered.

Parameter source

A GraphQL source string or source object.

Parameter options

Optional parser configuration.

Returns

The parsed GraphQL document AST.

Example 1

// Parse a GraphQL document with the default parser options.
import { parse } from 'graphql/language';

const document = parse('{ hero { name } }');

document.kind; // => 'Document'

Example 2

// This variant enables parser options and provides an explicit lexer.
import { Lexer, Source, parse } from 'graphql/language';

const document = parse(
  `
    {
      t { ...A(var: true) }
    }
    fragment A($var: Boolean = false) on T {
      name
    }
  `,
  {
    experimentalFragmentArguments: true,
    maxTokens: 80,
    noLocation: true,
  },
);
const directiveDocument = parse('directive @foo @bar on FIELD');
const source = new Source('{ hero }');
const lexerDocument = parse(source, { lexer: new Lexer(source) });

document.definitions[0].kind; // => 'OperationDefinition'
document.definitions[1].kind; // => 'FragmentDefinition'
document.loc; // => undefined
directiveDocument.definitions[0].kind; // => 'DirectiveDefinition'
lexerDocument.definitions[0].kind; // => 'OperationDefinition'

function parseConstValue

parseConstValue: (
    source: string | Source,
    options?: ParseOptions
) => ConstValueNode;

Similar to parseValue(), but raises a parse error if it encounters a variable. The return type will be a constant value.
Parameter source
A GraphQL source string or source object containing a constant value.
Parameter options
Optional parser configuration.
Returns
The parsed GraphQL constant value AST.
Example 1
import { parseConstValue } from 'graphql/language'; const value = parseConstValue('{ enabled: true }'); value.kind; // => 'ObjectValue' parseConstValue('$variable'); // throws an error

function parseSchemaCoordinate

parseSchemaCoordinate: (source: string | Source) => SchemaCoordinateNode;

Given a string containing a GraphQL Schema Coordinate (ex. Type.field), parse the AST for that schema coordinate. Throws GraphQLError if a syntax error is encountered.
Consider providing the results to the utility function: resolveASTSchemaCoordinate(). Or calling resolveSchemaCoordinate() directly with an unparsed source.
Parameter source
A GraphQL source string or source object containing a schema coordinate.
Returns
The parsed GraphQL schema coordinate AST.
Example 1
import { parseSchemaCoordinate } from 'graphql/language'; const coordinate = parseSchemaCoordinate('Query.hero'); coordinate.kind; // => 'MemberCoordinate'

function parseType

parseType: (source: string | Source, options?: ParseOptions) => TypeNode;

Given a string containing a GraphQL Type (ex. [Int!]), parse the AST for that type. Throws GraphQLError if a syntax error is encountered.
This is useful within tools that operate upon GraphQL Types directly and in isolation of complete GraphQL documents.
Consider providing the results to the utility function: typeFromAST().
Parameter source
A GraphQL source string or source object containing a type reference.
Parameter options
Optional parser configuration.
Returns
The parsed GraphQL type AST.
Example 1
import { parseType } from 'graphql/language'; const type = parseType('[String!]'); type.kind; // => 'ListType'

function parseValue

parseValue: (source: string | Source, options?: ParseOptions) => ValueNode;

Given a string containing a GraphQL value (ex. [42]), parse the AST for that value. Throws GraphQLError if a syntax error is encountered.
This is useful within tools that operate upon GraphQL Values directly and in isolation of complete GraphQL documents.
Consider providing the results to the utility function: valueFromAST().
Parameter source
A GraphQL source string or source object containing a value.
Parameter options
Optional parser configuration.
Returns
The parsed GraphQL value AST.
Example 1
import { parseValue } from 'graphql/language'; const value = parseValue('[42]'); value.kind; // => 'ListValue'

function PossibleFragmentSpreadsRule

PossibleFragmentSpreadsRule: (context: ValidationContext) => ASTVisitor;

Possible fragment spread

A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { PossibleFragmentSpreadsRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    dog: Dog
  }

  type Dog {
    barkVolume: Int
  }

  type Cat {
    meowVolume: Int
  }
`);

const invalidDocument = parse(`
  { dog { ... on Cat { meowVolume } } }
`);
const invalidErrors = validate(schema, invalidDocument, [
  PossibleFragmentSpreadsRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { dog { ... on Dog { barkVolume } } }
`);
const validErrors = validate(schema, validDocument, [
  PossibleFragmentSpreadsRule,
]);

validErrors; // => []

function PossibleTypeExtensionsRule

PossibleTypeExtensionsRule: (context: SDLValidationContext) => ASTVisitor;

Possible type extension

A type extension is only valid if the type is defined and has the same kind.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema } from 'graphql';
import { PossibleTypeExtensionsRule } from 'graphql/validation';

const invalidSDL = `
  extend type Missing { name: String } type Query { name: String }
`;

PossibleTypeExtensionsRule.name; // => 'PossibleTypeExtensionsRule'
buildSchema(invalidSDL); // throws an error

const validSDL = `
  type Query { name: String } extend type Query { other: String }
`;

buildSchema(validSDL); // does not throw

function print

print: (ast: ASTNode) => string;

Converts an AST into a string, using one set of reasonable formatting rules.
Parameter ast
The GraphQL AST node to print.
Returns
A stable string representation of the AST.
Example 1
import { parse, print } from 'graphql'; const ast = parse('{ hero { name } }'); const text = print(ast); text; // => '{\n hero {\n name\n }\n}'

function printDirective

printDirective: (directive: GraphQLDirective) => string;

Prints a directive definition in GraphQL SDL.

Parameter directive

Directive to print.

Returns

SDL string for the directive definition.

Example 1

import {
  DirectiveLocation,
  GraphQLDirective,
  GraphQLString,
} from 'graphql/type';
import { printDirective } from 'graphql/utilities';

const authDirective = new GraphQLDirective({
  name: 'auth',
  description: 'Requires authorization.',
  locations: [DirectiveLocation.FIELD_DEFINITION],
  args: {
    scope: { type: GraphQLString },
  },
});

printDirective(authDirective); // => '"""Requires authorization."""\ndirective @auth(scope: String) on FIELD_DEFINITION'

function printIntrospectionSchema

printIntrospectionSchema: (schema: GraphQLSchema) => string;

Prints the introspection schema.

Parameter schema

GraphQL schema to use.

Returns

The printed string representation.

Example 1

import { buildSchema, printIntrospectionSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);

const printed = printIntrospectionSchema(schema);

printed; // matches /type __Schema/
printed; // matches /enum __TypeKind/
printed; // does not match /type Query/

function printLocation

printLocation: (location: Location) => string;

Render a helpful description of the location in the GraphQL Source document.

Parameter location

The AST location to print.

Returns

A formatted source excerpt with line and column information.

Example 1

import { parse, printLocation } from 'graphql/language';

const document = parse('type Query { hello: String }');
const location = document.definitions[0].loc;

if (location) {
  const printed = printLocation(location);

  printed; // => 'GraphQL request:1:1\n1 | type Query { hello: String }\n  | ^'
}

function printSchema

printSchema: (schema: GraphQLSchema) => string;

Prints the schema.

Parameter schema

GraphQL schema to use.

Returns

The printed string representation.

Example 1

import { buildSchema, printSchema } from 'graphql/utilities';

const schema = buildSchema(`
  directive @upper on FIELD_DEFINITION

  type Query {
    greeting: String @upper
  }
`);

printSchema(schema); // => ['directive @upper on FIELD_DEFINITION', '', 'type Query {', '  greeting: String', '}'].join('\n')

function printSourceLocation

printSourceLocation: (source: Source, sourceLocation: SourceLocation) => string;

Render a helpful description of the location in the GraphQL Source document.

Parameter source

The source document that contains the location.

Parameter sourceLocation

The 1-indexed line and column to print.

Returns

A formatted source excerpt with line and column information.

Example 1

import { Source, printSourceLocation } from 'graphql/language';

const source = new Source('type Query { hello: String }');
const printed = printSourceLocation(source, { line: 1, column: 14 });

printed; // => 'GraphQL request:1:14\n1 | type Query { hello: String }\n  |              ^'

function printType

printType: (type: GraphQLNamedType) => string;

Prints the type.

Parameter type

The GraphQL type to inspect.

Returns

The printed string representation.

Example 1

import { buildSchema, printType } from 'graphql/utilities';

const schema = buildSchema(`
  type User {
    id: ID!
    name: String
  }

  type Query {
    viewer: User
  }
`);

printType(schema.getType('User')); // => ['type User {', '  id: ID!', '  name: String', '}'].join('\n')

function ProvidedRequiredArgumentsRule

ProvidedRequiredArgumentsRule: (context: ValidationContext) => ASTVisitor;

Provided required arguments

A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { ProvidedRequiredArgumentsRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    field(required: String!): String
  }
`);

const invalidDocument = parse(`
  { field }
`);
const invalidErrors = validate(schema, invalidDocument, [
  ProvidedRequiredArgumentsRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { field(required: "x") }
`);
const validErrors = validate(schema, validDocument, [
  ProvidedRequiredArgumentsRule,
]);

validErrors; // => []

function replaceVariables

replaceVariables: (
    valueNode: ValueNode,
    variableValues?: Maybe<VariableValues>,
    fragmentVariableValues?: Maybe<FragmentVariableValues>
) => ConstValueNode;

Replaces any Variables found within an AST Value literal with literals supplied from a map of variable values, or removed if no variable replacement exists, returning a constant value.

Used primarily to ensure only complete constant values are used during input coercion of custom scalars which accept complex literals.

Parameter valueNode

Value AST node in which variables should be replaced.

Parameter variableValues

Operation variable values returned by getVariableValues.

Parameter fragmentVariableValues

Fragment variable values for the current fragment scope.

Returns

A constant value AST with variables replaced.

Example 1

import assert from 'node:assert';
import { parse, parseValue, print } from 'graphql/language';
import { getVariableValues } from 'graphql/execution';
import { buildSchema, replaceVariables } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    review(stars: Int = 5): String
  }
`);
const document = parse('query ($stars: Int = 5) { review(stars: $stars) }');
const operation = document.definitions[0];
const result = getVariableValues(schema, operation.variableDefinitions, {
  stars: 4,
});

assert('variableValues' in result);

const literal = replaceVariables(
  parseValue('{ stars: $stars, comment: $missing }'),
  result.variableValues,
);

print(literal); // => '{ stars: 4 }'

function resolveASTSchemaCoordinate

resolveASTSchemaCoordinate: (
    schema: GraphQLSchema,
    schemaCoordinate: SchemaCoordinateNode
) => ResolvedSchemaElement | undefined;

Resolves schema coordinate from a parsed SchemaCoordinate node.

Parameter schema

GraphQL schema to use.

Parameter schemaCoordinate

The schema coordinate to resolve.

Returns

The schema element identified by the parsed coordinate, or undefined if none exists.

Example 1

import { parseSchemaCoordinate } from 'graphql/language';
import { buildSchema, resolveASTSchemaCoordinate } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting(name: String): String
  }
`);
const coordinate = parseSchemaCoordinate('Query.greeting(name:)');
const resolved = resolveASTSchemaCoordinate(schema, coordinate);

resolved.kind; // => 'FieldArgument'
resolved.field.name; // => 'greeting'
resolved.fieldArgument.name; // => 'name'

function resolveObjMapThunk

resolveObjMapThunk: <T>(thunk: ThunkObjMap<T>) => ObjMap<T>;

Resolves a thunked object map.

Parameter thunk

The thunk or value to resolve.

Returns

The resolved object map.

Example 1

import { GraphQLString, resolveObjMapThunk } from 'graphql/type';

const lazyFields = resolveObjMapThunk(() => ({ name: GraphQLString }));
const fields = resolveObjMapThunk({ name: GraphQLString });

lazyFields.name; // => GraphQLString
fields.name; // => GraphQLString

function resolveReadonlyArrayThunk

resolveReadonlyArrayThunk: <T>(thunk: ThunkReadonlyArray<T>) => ReadonlyArray<T>;

Resolves a thunked readonly array.

Parameter thunk

The thunk or value to resolve.

Returns

The resolved readonly array.

Example 1

import { GraphQLString, resolveReadonlyArrayThunk } from 'graphql/type';

const lazyFields = resolveReadonlyArrayThunk(() => [GraphQLString]);
const fields = resolveReadonlyArrayThunk([GraphQLString]);

lazyFields; // => [GraphQLString]
fields; // => [GraphQLString]

function resolveSchemaCoordinate

resolveSchemaCoordinate: (
    schema: GraphQLSchema,
    schemaCoordinate: string | Source
) => ResolvedSchemaElement | undefined;

A schema coordinate is resolved in the context of a GraphQL schema to uniquely identify a schema element. It returns undefined if the schema coordinate does not resolve to a schema element, meta-field, or introspection schema element. It will throw if the containing schema element (if applicable) does not exist.

https://spec.graphql.org/draft/#sec-Schema-Coordinates.Semantics

Parameter schema

GraphQL schema to use.

Parameter schemaCoordinate

The schema coordinate to resolve.

Returns

The schema element identified by the coordinate, or undefined if none exists.

Example 1

import { buildSchema, resolveSchemaCoordinate } from 'graphql/utilities';

const schema = buildSchema(`
  directive @tag(name: String!) on FIELD_DEFINITION

  input ReviewInput {
    stars: Int!
  }

  enum Episode {
    NEW_HOPE
  }

  type Query {
    reviews(input: ReviewInput): [String] @tag(name: "reviews")
  }
`);

resolveSchemaCoordinate(schema, 'Query').kind; // => 'NamedType'
resolveSchemaCoordinate(schema, 'Query.reviews').kind; // => 'Field'
resolveSchemaCoordinate(schema, 'Query.reviews(input:)').kind; // => 'FieldArgument'
resolveSchemaCoordinate(schema, 'ReviewInput.stars').kind; // => 'InputField'
resolveSchemaCoordinate(schema, 'Episode.NEW_HOPE').kind; // => 'EnumValue'
resolveSchemaCoordinate(schema, '@tag').kind; // => 'Directive'
resolveSchemaCoordinate(schema, '@tag(name:)').kind; // => 'DirectiveArgument'
resolveSchemaCoordinate(schema, 'Query.missing'); // => undefined

function responsePathAsArray

responsePathAsArray: (path: Maybe<Readonly<Path>>) => Array<string | number>;

Given a Path, return an Array of the path keys.

Parameter path

The linked response path to flatten.

Returns

An array of response path keys from root to leaf.

Example 1

import { pathToArray } from 'graphql/jsutils/Path';

const path = {
  prev: {
    prev: {
      prev: undefined,
      key: 'viewer',
      typename: 'Query',
    },
    key: 'friends',
    typename: 'User',
  },
  key: 0,
  typename: undefined,
};

pathToArray(path); // => ['viewer', 'friends', 0]
pathToArray(undefined); // => []

function ScalarLeafsRule

ScalarLeafsRule: (context: ValidationContext) => ASTVisitor;

Scalar leafs

A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { ScalarLeafsRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  { name { length } }
`);
const invalidErrors = validate(schema, invalidDocument, [ScalarLeafsRule]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { name }
`);
const validErrors = validate(schema, validDocument, [ScalarLeafsRule]);

validErrors; // => []

function separateOperations

separateOperations: (documentAST: DocumentNode) => ObjMap<DocumentNode>;

separateOperations accepts a single AST document which may contain many operations and fragments and returns a collection of AST documents each of which contains a single operation as well the fragment definitions it refers to.

Parameter documentAST

The parsed GraphQL document AST.

Returns

A map of operation names to documents containing each operation and its referenced fragments.

Example 1

import { parse, print } from 'graphql/language';
import { separateOperations } from 'graphql/utilities';

const document = parse(`
  query GetUser {
    viewer {
      ...UserFields
    }
  }

  query GetStatus {
    status
  }

  fragment UserFields on User {
    id
  }
`);

const separated = separateOperations(document);

Object.keys(separated); // => ['GetUser', 'GetStatus']
print(separated.GetUser); // matches /fragment UserFields/
print(separated.GetStatus); // does not match /fragment UserFields/

function SingleFieldSubscriptionsRule

SingleFieldSubscriptionsRule: (context: ValidationContext) => ASTVisitor;

Subscriptions must only include a non-introspection field.

A GraphQL subscription is valid only if it contains a single root field and that root field is not an introspection field.

See https://spec.graphql.org/draft/#sec-Single-root-field

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { SingleFieldSubscriptionsRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }

  type Subscription {
    a: String
    b: String
  }
`);

const invalidDocument = parse(`
  subscription { a b }
`);
const invalidErrors = validate(schema, invalidDocument, [
  SingleFieldSubscriptionsRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  subscription { a }
`);
const validErrors = validate(schema, validDocument, [
  SingleFieldSubscriptionsRule,
]);

validErrors; // => []

function StreamDirectiveOnListFieldRule

StreamDirectiveOnListFieldRule: (context: ValidationContext) => ASTVisitor;

Stream directives are used on list fields

A GraphQL document is only valid if stream directives are used on list fields.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { validate, StreamDirectiveOnListFieldRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
    friends: [String]
  }
`);
const invalidDocument = parse('{ name @stream(initialCount: 0) }');
const validDocument = parse('{ friends @stream(initialCount: 0) }');

validate(schema, invalidDocument, [StreamDirectiveOnListFieldRule]).length; // => 1
validate(schema, validDocument, [StreamDirectiveOnListFieldRule]); // => []

function stripIgnoredCharacters

stripIgnoredCharacters: (source: string | Source) => string;

Strips characters that are not significant to the validity or execution of a GraphQL document: - UnicodeBOM - WhiteSpace - LineTerminator - Comment - Comma - BlockString indentation
Note: It is required to have a delimiter character between neighboring non-punctuator tokens and this function always uses single space as delimiter.
It is guaranteed that both input and output documents if parsed would result in the exact same AST except for nodes location.
Warning: It is guaranteed that this function will always produce stable results. However, it's not guaranteed that it will stay the same between different releases due to bugfixes or changes in the GraphQL specification.
Parameter source
The GraphQL source text or source object.
Returns
A semantically equivalent GraphQL source string without ignored characters.
Example 1
Query source
query SomeQuery($foo: String!, $bar: String) { someField(foo: $foo, bar: $bar) { a b { c d } } }
Becomes:
query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}
Example 2
SDL source
""" Type description """ type Foo { """ Field description """ bar: String }
Becomes:
"""Type description""" type Foo{"""Field description""" bar:String}
Example 3
import { stripIgnoredCharacters } from 'graphql/utilities'; const source = stripIgnoredCharacters('query Example { name }'); source; // => 'query Example{name}'

subscribe: (
    args: ExecutionArgs
) => PromiseOrValue<AsyncGenerator<ExecutionResult, void, void> | ExecutionResult>;

Implements the "Subscribe" algorithm described in the GraphQL specification.

Returns either an AsyncGenerator (if successful), an ExecutionResult (error), or a Promise for one of those results. The call will throw immediately if the schema is invalid or the selected operation is not a subscription.

GraphQL request errors, including missing operations and variable coercion errors, return or resolve to a GraphQL Response (ExecutionResult) with descriptive errors and no data.

If the source stream could not be created due to faulty subscription resolver logic, a non-async-iterable resolver result, or a system error, the function will return or resolve to a single ExecutionResult containing errors and no data.

If the operation succeeded, the function returns or resolves to an AsyncGenerator, which yields a stream of ExecutionResults representing the response stream.

This function does not support incremental delivery (@defer and @stream). If an operation which would defer or stream data is executed with this function, a field error will be raised at the location of the @defer or @stream directive.

Accepts an object with named arguments.

Parameter args

Execution arguments for the subscription operation.

Returns

A response stream for a valid subscription, or an execution result containing errors.

Example 1

// Use a same-named rootValue function to provide the source event stream.
import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { subscribe } from 'graphql/execution';

async function* greetings() {
  yield { greeting: 'Hello' };
  yield { greeting: 'Bonjour' };
}

const schema = buildSchema(`
  type Query {
    noop: String
  }

  type Subscription {
    greeting: String
  }
`);

const result = await subscribe({
  schema,
  document: parse('subscription { greeting }'),
  rootValue: { greeting: () => greetings() },
});

assert('next' in result);

const firstPayload = await result.next();
firstPayload.value; // => { data: { greeting: 'Hello' } }

Example 2

// This variant supplies events through a custom subscribeFieldResolver.
import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { subscribe } from 'graphql/execution';

async function* defaultGreetings() {
  yield { greeting: 'Hello' };
}

async function* frenchGreetings() {
  yield { greeting: 'Bonjour' };
}

const schema = buildSchema(`
  type Query {
    noop: String
  }

  type Subscription {
    greeting(locale: String): String
  }
`);

const result = await subscribe({
  schema,
  document: parse(
    'subscription Greeting($locale: String) { greeting(locale: $locale) }',
  ),
  rootValue: {
    greeting: (args, contextValue) => {
      const locale = args.locale ?? contextValue.defaultLocale;
      return locale === 'fr' ? frenchGreetings() : defaultGreetings();
    },
  },
  contextValue: { defaultLocale: 'fr' },
  variableValues: { locale: 'fr' },
  operationName: 'Greeting',
  subscribeFieldResolver: (rootValue, args, contextValue, info) => {
    args.locale; // => 'fr'
    return rootValue[info.fieldName](args, contextValue);
  },
});

assert('next' in result);

const firstPayload = await result.next();
firstPayload.value; // => { data: { greeting: 'Bonjour' } }

function syntaxError

syntaxError: (
    source: Source,
    position: number,
    description: string
) => GraphQLError;

Produces a GraphQLError representing a syntax error, containing useful descriptive information about the syntax error's position in the source.
Parameter source
The GraphQL source containing the syntax error.
Parameter position
Character offset where the syntax error was encountered.
Parameter description
Human-readable description of the syntax error.
Returns
A GraphQLError located at the syntax error position.
Example 1
import { Source } from 'graphql/language'; import { syntaxError } from 'graphql/error'; const error = syntaxError(new Source('query {'), 7, 'Expected Name'); error.message; // => 'Syntax Error: Expected Name' error.locations; // => [{ line: 1, column: 8 }]

function typeFromAST

typeFromAST: {
    (schema: GraphQLSchema, typeNode: NamedTypeNode): GraphQLNamedType | undefined;
    (schema: GraphQLSchema, typeNode: ListTypeNode): GraphQLList<any>;
    (schema: GraphQLSchema, typeNode: NonNullTypeNode): GraphQLNonNull<any>;
    (schema: GraphQLSchema, typeNode: TypeNode): GraphQLType;
};

Given a Schema and an AST node describing a type, return a GraphQLType definition which applies to that type. For example, if provided the parsed AST node for [User], a GraphQLList instance will be returned, containing the type called "User" found in the schema. If a type called "User" is not found in the schema, then undefined will be returned.
Parameter schema
GraphQL schema to use.
Parameter typeNode
The GraphQL type AST node to resolve.
Returns
The GraphQL type referenced by the AST node, or undefined if it cannot be resolved.
Example 1
import { parseType } from 'graphql/language'; import { buildSchema, typeFromAST } from 'graphql/utilities'; const schema = buildSchema(` type Query { name: String } `); typeFromAST(schema, parseType('String'))?.toString(); // => 'String' typeFromAST(schema, parseType('Missing')); // => undefined

Resolves a list type AST node against a schema.

Parameter schema

GraphQL schema to use.

Parameter typeNode

The list type AST node to resolve.

Returns

The GraphQL list type referenced by the AST node, or undefined if it cannot be resolved.

Example 1

import { parseType } from 'graphql/language';
import { buildSchema, typeFromAST } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    tags: [String]
  }
`);

typeFromAST(schema, parseType('[String]'))?.toString(); // => '[String]'
typeFromAST(schema, parseType('[Missing]')); // => undefined

Resolves a non-null type AST node against a schema.

Parameter schema

GraphQL schema to use.

Parameter typeNode

The non-null type AST node to resolve.

Returns

The GraphQL non-null type referenced by the AST node, or undefined if it cannot be resolved.

Example 1

import { parseType } from 'graphql/language';
import { buildSchema, typeFromAST } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    name: String!
  }
`);

typeFromAST(schema, parseType('String!'))?.toString(); // => 'String!'
typeFromAST(schema, parseType('[String!]!'))?.toString(); // => '[String!]!'

Resolves a type AST node against a schema.

Parameter schema

GraphQL schema to use.

Parameter typeNode

The GraphQL type AST node to resolve.

Returns

The GraphQL type referenced by the AST node, or undefined if it cannot be resolved.

Example 1

import { parseType } from 'graphql/language';
import { buildSchema, typeFromAST } from 'graphql/utilities';

const schema = buildSchema(`
  type User {
    name: String
  }

  type Query {
    users: [User!]!
  }
`);

typeFromAST(schema, parseType('User'))?.toString(); // => 'User'
typeFromAST(schema, parseType('[User!]!'))?.toString(); // => '[User!]!'
typeFromAST(schema, parseType('Missing')); // => undefined

function UniqueArgumentDefinitionNamesRule

UniqueArgumentDefinitionNamesRule: (context: SDLValidationContext) => ASTVisitor;

Unique argument definition names

A GraphQL Object or Interface type is only valid if all its fields have uniquely named arguments. A GraphQL Directive is only valid if all its arguments are uniquely named.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema } from 'graphql';
import { UniqueArgumentDefinitionNamesRule } from 'graphql/validation';

const invalidSDL = `
  type Query { field(arg: String, arg: Int): String }
`;

UniqueArgumentDefinitionNamesRule.name; // => 'UniqueArgumentDefinitionNamesRule'
buildSchema(invalidSDL); // throws an error

const validSDL = `
  type Query { field(arg: String): String }
`;

buildSchema(validSDL); // does not throw

function UniqueArgumentNamesRule

UniqueArgumentNamesRule: (context: ASTValidationContext) => ASTVisitor;

Unique argument names

A GraphQL field or directive is only valid if all supplied arguments are uniquely named.

See https://spec.graphql.org/draft/#sec-Argument-Names

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { UniqueArgumentNamesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    field(arg: String): String
  }
`);

const invalidDocument = parse(`
  { field(arg: "1", arg: "2") }
`);
const invalidErrors = validate(schema, invalidDocument, [
  UniqueArgumentNamesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { field(arg: "1") }
`);
const validErrors = validate(schema, validDocument, [UniqueArgumentNamesRule]);

validErrors; // => []

function UniqueDirectiveNamesRule

UniqueDirectiveNamesRule: (context: SDLValidationContext) => ASTVisitor;

Unique directive names

A GraphQL document is only valid if all defined directives have unique names.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema } from 'graphql';
import { UniqueDirectiveNamesRule } from 'graphql/validation';

const invalidSDL = `
  directive @tag on FIELD directive @tag on QUERY type Query { name: String }
`;

UniqueDirectiveNamesRule.name; // => 'UniqueDirectiveNamesRule'
buildSchema(invalidSDL); // throws an error

const validSDL = `
  directive @tag on FIELD type Query { name: String }
`;

buildSchema(validSDL); // does not throw

function UniqueDirectivesPerLocationRule

UniqueDirectivesPerLocationRule: (
    context: ValidationContext | SDLValidationContext
) => ASTVisitor;

Unique directive names per location

A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.

See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { UniqueDirectivesPerLocationRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  { name @include(if: true) @include(if: false) }
`);
const invalidErrors = validate(schema, invalidDocument, [
  UniqueDirectivesPerLocationRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { name @include(if: true) }
`);
const validErrors = validate(schema, validDocument, [
  UniqueDirectivesPerLocationRule,
]);

validErrors; // => []

function UniqueEnumValueNamesRule

UniqueEnumValueNamesRule: (context: SDLValidationContext) => ASTVisitor;

Unique enum value names

A GraphQL enum type is only valid if all its values are uniquely named.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema } from 'graphql';
import { UniqueEnumValueNamesRule } from 'graphql/validation';

const invalidSDL = `
  enum Status { ACTIVE ACTIVE } type Query { status: Status }
`;

UniqueEnumValueNamesRule.name; // => 'UniqueEnumValueNamesRule'
buildSchema(invalidSDL); // throws an error

const validSDL = `
  enum Status { ACTIVE INACTIVE } type Query { status: Status }
`;

buildSchema(validSDL); // does not throw

function UniqueFieldDefinitionNamesRule

UniqueFieldDefinitionNamesRule: (context: SDLValidationContext) => ASTVisitor;

Unique field definition names

A GraphQL complex type is only valid if all its fields are uniquely named.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema } from 'graphql';
import { UniqueFieldDefinitionNamesRule } from 'graphql/validation';

const invalidSDL = `
  type Query { name: String name: String }
`;

UniqueFieldDefinitionNamesRule.name; // => 'UniqueFieldDefinitionNamesRule'
buildSchema(invalidSDL); // throws an error

const validSDL = `
  type Query { name: String other: String }
`;

buildSchema(validSDL); // does not throw

function UniqueFragmentNamesRule

UniqueFragmentNamesRule: (context: ASTValidationContext) => ASTVisitor;

Unique fragment names

A GraphQL document is only valid if all defined fragments have unique names.

See https://spec.graphql.org/draft/#sec-Fragment-Name-Uniqueness

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { UniqueFragmentNamesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  fragment A on Query { name } fragment A on Query { name } query { ...A }
`);
const invalidErrors = validate(schema, invalidDocument, [
  UniqueFragmentNamesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  fragment A on Query { name } query { ...A }
`);
const validErrors = validate(schema, validDocument, [UniqueFragmentNamesRule]);

validErrors; // => []

function UniqueInputFieldNamesRule

UniqueInputFieldNamesRule: (context: ASTValidationContext) => ASTVisitor;

Unique input field names

A GraphQL input object value is only valid if all supplied fields are uniquely named.

See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { UniqueInputFieldNamesRule } from 'graphql/validation';

const schema = buildSchema(`
  input Filter {
    name: String
  }

  type Query {
    search(filter: Filter): String
  }
`);

const invalidDocument = parse(`
  { search(filter: { name: "a", name: "b" }) }
`);
const invalidErrors = validate(schema, invalidDocument, [
  UniqueInputFieldNamesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { search(filter: { name: "a" }) }
`);
const validErrors = validate(schema, validDocument, [
  UniqueInputFieldNamesRule,
]);

validErrors; // => []

function UniqueOperationNamesRule

UniqueOperationNamesRule: (context: ASTValidationContext) => ASTVisitor;

Unique operation names

A GraphQL document is only valid if all defined operations have unique names.

See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { UniqueOperationNamesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    name: String
  }
`);

const invalidDocument = parse(`
  query Same { name } query Same { name }
`);
const invalidErrors = validate(schema, invalidDocument, [
  UniqueOperationNamesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  query One { name } query Two { name }
`);
const validErrors = validate(schema, validDocument, [UniqueOperationNamesRule]);

validErrors; // => []

function UniqueOperationTypesRule

UniqueOperationTypesRule: (context: SDLValidationContext) => ASTVisitor;

Unique operation types

A GraphQL document is only valid if it has only one type per operation.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema } from 'graphql';
import { UniqueOperationTypesRule } from 'graphql/validation';

const invalidSDL = `
  schema { query: Query query: Other } type Query { name: String } type Other { name: String }
`;

UniqueOperationTypesRule.name; // => 'UniqueOperationTypesRule'
buildSchema(invalidSDL); // throws an error

const validSDL = `
  schema { query: Query } type Query { name: String }
`;

buildSchema(validSDL); // does not throw

function UniqueTypeNamesRule

UniqueTypeNamesRule: (context: SDLValidationContext) => ASTVisitor;

Unique type names

A GraphQL document is only valid if all defined types have unique names.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema } from 'graphql';
import { UniqueTypeNamesRule } from 'graphql/validation';

const invalidSDL = `
  type Query { name: String } type Query { other: String }
`;

UniqueTypeNamesRule.name; // => 'UniqueTypeNamesRule'
buildSchema(invalidSDL); // throws an error

const validSDL = `
  type Query { name: String } type Other { name: String }
`;

buildSchema(validSDL); // does not throw

function UniqueVariableNamesRule

UniqueVariableNamesRule: (context: ASTValidationContext) => ASTVisitor;

Unique variable names

A GraphQL operation is only valid if all its variables are uniquely named.

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { UniqueVariableNamesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    field(arg: ID): String
  }
`);

const invalidDocument = parse(`
  query ($id: ID, $id: ID) { field(arg: $id) }
`);
const invalidErrors = validate(schema, invalidDocument, [
  UniqueVariableNamesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  query ($id: ID) { field(arg: $id) }
`);
const validErrors = validate(schema, validDocument, [UniqueVariableNamesRule]);

validErrors; // => []

function validate

validate: (
    schema: GraphQLSchema,
    documentAST: DocumentNode,
    rules?: ReadonlyArray<ValidationRule>,
    options?: ValidationOptions
) => ReadonlyArray<GraphQLError>;

Implements the "Validation" section of the spec.

Validation runs synchronously, returning an array of encountered errors, or an empty array if no errors were encountered and the document is valid.

A list of specific validation rules may be provided. If not provided, the default list of rules defined by the GraphQL specification will be used.

Each validation rule is a function that returns a visitor (see the language/visitor API). Visitor methods are expected to return GraphQLErrors, or Arrays of GraphQLErrors when invalid.

Validate will stop validation after a maxErrors limit has been reached. Attackers can send pathologically invalid queries to induce a DoS attack, so maxErrors defaults to 100 errors.

Parameter schema

Schema to validate against.

Parameter documentAST

Document AST to validate.

Parameter rules

Validation rules to apply.

Parameter options

Validation options, including error limits and suggestions.

Returns

Validation errors, or an empty array when the document is valid.

Example 1

// Validate with the default specified rules.
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { validate } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    fullName: String
  }
`);

validate(schema, parse('{ greeting }')); // => []

const errors = validate(schema, parse('{ missing }'));
errors[0].message; // => 'Cannot query field "missing" on type "Query".'

Example 2

// This variant uses a custom rule list and validation options.
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { FieldsOnCorrectTypeRule, validate } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse('{ missingOne missingTwo }');

const errors = validate(schema, document, [FieldsOnCorrectTypeRule], {
  maxErrors: 1,
});

errors.length; // => 2
errors[1].message; // => 'Too many validation errors, error limit reached. Validation aborted.'

const hiddenSuggestionErrors = validate(
  schema,
  parse('{ name }'),
  [FieldsOnCorrectTypeRule],
  { hideSuggestions: true },
);

hiddenSuggestionErrors[0].message; // => 'Cannot query field "name" on type "Query".'

function validateExecutionArgs

validateExecutionArgs: (
    args: ExecutionArgs
) => ReadonlyArray<GraphQLError> | ValidatedExecutionArgs;

Validates the arguments passed to execute, subscribe, and their lower-level helpers.

Throws if the schema is invalid. GraphQL request errors, including variable coercion errors, are returned as a GraphQLError array.

Parameter args

Execution arguments to validate.

Returns

Validated execution arguments, or validation errors.

Example 1

import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { validateExecutionArgs } from 'graphql/execution';

const schema = buildSchema(`
  interface Named {
    name: String!
  }

  type User implements Named {
    name: String!
  }

  type Query {
    viewer: Named
  }
`);
const abortController = new AbortController();
const validatedArgs = validateExecutionArgs({
  schema,
  document: parse('query Viewer { viewer { __typename name } }'),
  rootValue: { viewer: { kind: 'user', name: 'Ada' } },
  contextValue: { locale: 'en' },
  operationName: 'Viewer',
  fieldResolver: (source, _args, contextValue, info) => {
    contextValue.locale; // => 'en'
    return source[info.fieldName];
  },
  typeResolver: (value) => {
    return value.kind === 'user' ? 'User' : undefined;
  },
  hideSuggestions: true,
  abortSignal: abortController.signal,
  enableEarlyExecution: true,
  hooks: {
    asyncWorkFinished: () => {},
  },
  options: { maxCoercionErrors: 1 },
});

assert('operation' in validatedArgs);

validatedArgs.operation.name?.value; // => 'Viewer'
validatedArgs.hideSuggestions; // => true

function validateInputLiteral

validateInputLiteral: (
    valueNode: ValueNode,
    type: GraphQLInputType,
    onError: (error: GraphQLError, path: ReadonlyArray<string | number>) => void,
    variables?: Maybe<VariableValues>,
    fragmentVariableValues?: Maybe<FragmentVariableValues>,
    hideSuggestions?: Maybe<boolean>
) => void;

Validate that the provided input literal is allowed for this type, collecting all errors via a callback function.

If variable values are not provided, the literal is validated statically (not assuming that those variables are missing runtime values).

Parameter valueNode

GraphQL value AST node to validate.

Parameter type

GraphQL input type to validate the literal against.

Parameter onError

Callback invoked for each validation error and path.

Parameter variables

Operation variable values returned by getVariableValues.

Parameter fragmentVariableValues

Fragment variable values for the current fragment scope.

Parameter hideSuggestions

Whether suggestion text should be omitted from errors.

Returns

Nothing.

Example 1

// Validate literal input values and collect literal paths.
import { parseValue } from 'graphql/language';
import {
  GraphQLInputObjectType,
  GraphQLInt,
  GraphQLNonNull,
} from 'graphql/type';
import { validateInputLiteral } from 'graphql/utilities';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {
    stars: { type: new GraphQLNonNull(GraphQLInt) },
  },
});
const errors = [];

validateInputLiteral(
  parseValue('{ stars: "bad" }'),
  ReviewInput,
  (error, path) => {
    errors.push({ message: error.message, path });
  },
);

errors; // => [ { message: 'Expected value of type "Int", found: "bad".', path: ['stars'] } ]

Example 2

// This variant resolves variable references using VariableValues from getVariableValues().
import assert from 'node:assert';
import { parse, parseValue } from 'graphql/language';
import { GraphQLInt } from 'graphql/type';
import { getVariableValues } from 'graphql/execution';
import { buildSchema, validateInputLiteral } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    review(stars: Int): String
  }
`);
const document = parse('query ($stars: Int = 5) { review(stars: $stars) }');
const operation = document.definitions[0];
const result = getVariableValues(schema, operation.variableDefinitions, {
  stars: '4',
});

assert('variableValues' in result);

const errors = [];
validateInputLiteral(
  parseValue('$stars'),
  GraphQLInt,
  (error) => errors.push(error.message),
  result.variableValues,
  undefined,
  true,
);

errors; // => []

function validateInputValue

validateInputValue: (
    inputValue: unknown,
    type: GraphQLInputType,
    onError: (error: GraphQLError, path: ReadonlyArray<string | number>) => void,
    hideSuggestions?: Maybe<boolean>
) => void;

Validate that the provided input value is allowed for this type, collecting all errors via a callback function.

Parameter inputValue

JavaScript value to validate.

Parameter type

GraphQL input type to validate the value against.

Parameter onError

Callback invoked for each validation error and path.

Parameter hideSuggestions

Whether suggestion text should be omitted from errors.

Returns

Nothing.

Example 1

// Collect validation errors with their input paths.
import {
  GraphQLInputObjectType,
  GraphQLInt,
  GraphQLNonNull,
} from 'graphql/type';
import { validateInputValue } from 'graphql/utilities';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {
    stars: { type: new GraphQLNonNull(GraphQLInt) },
  },
});
const errors = [];

validateInputValue({ stars: 'bad' }, ReviewInput, (error, path) => {
  errors.push({ message: error.message, path });
});

errors; // => [ { message: 'Expected value of type "Int", found: "bad".', path: ['stars'] } ]

Example 2

// This variant hides suggestion text for unknown input fields.
import { GraphQLInputObjectType, GraphQLString } from 'graphql/type';
import { validateInputValue } from 'graphql/utilities';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {
    comment: { type: GraphQLString },
  },
});
const errors = [];

validateInputValue(
  { rating: 'extra field' },
  ReviewInput,
  (error) => {
    errors.push(error.message);
  },
  true,
);

errors; // => ['Expected value of type "ReviewInput" not to include unknown field "rating", found: { rating: "extra field" }.']

function validateSchema

validateSchema: (schema: GraphQLSchema) => ReadonlyArray<GraphQLError>;

Implements the "Type Validation" sub-sections of the specification's "Type System" section.
Validation runs synchronously, returning an array of encountered errors, or an empty array if no errors were encountered and the Schema is valid.
Parameter schema
GraphQL schema to use.
Returns
Schema validation errors, or an empty array when the schema is valid.
Example 1
import { validateSchema } from 'graphql/type'; import { buildSchema } from 'graphql/utilities'; const schema = buildSchema(` type Query { name: String } `); const errors = validateSchema(schema); errors; // => []

function validateSubscriptionArgs

validateSubscriptionArgs: (
    args: ExecutionArgs
) => ReadonlyArray<GraphQLError> | ValidatedSubscriptionArgs;

Validates execution arguments for a subscription operation.

Throws if the schema is invalid or the selected operation is not a subscription. GraphQL request errors, including variable coercion errors, are returned as a GraphQLError array.

Parameter args

Execution arguments to validate.

Returns

Validated subscription execution arguments, or validation errors.

Example 1

import assert from 'node:assert';
import { parse } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { validateSubscriptionArgs } from 'graphql/execution';

const schema = buildSchema(`
  type Query {
    noop: String
  }

  type Subscription {
    greeting: String
  }
`);
const validatedArgs = validateSubscriptionArgs({
  schema,
  document: parse('subscription { greeting }'),
});

assert('operation' in validatedArgs);

validatedArgs.operation.operation; // => 'subscription'

function valueFromAST

valueFromAST: (
    valueNode: Maybe<ValueNode>,
    type: GraphQLInputType,
    variables?: Maybe<ObjMap<unknown>>
) => unknown;

Produces a JavaScript value given a GraphQL Value AST.

A GraphQL type must be provided, which will be used to interpret different GraphQL Value literals.

Returns undefined when the value could not be validly coerced according to the provided type.

This deprecated function will be removed in v18. Use coerceInputLiteral() instead.

| GraphQL Value | JSON Value | | -------------------- | ------------- | | Input Object | Object | | List | Array | | Boolean | Boolean | | String | String | | Int / Float | Number | | Enum Value | Unknown | | NullValue | null |

Parameter valueNode

GraphQL value AST node to convert.

Parameter type

The GraphQL type to inspect.

Parameter variables

Optional runtime variable values keyed by variable name.

Returns

The coerced JavaScript value, or undefined if the AST value cannot be coerced to the type.

Example 1

// Coerce literal values without variables.
import { parseValue } from 'graphql/language';
import {
  GraphQLInputObjectType,
  GraphQLInt,
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
} from 'graphql/type';
import { valueFromAST } from 'graphql/utilities';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {
    stars: { type: new GraphQLNonNull(GraphQLInt) },
    tags: { type: new GraphQLList(GraphQLString) },
  },
});

valueFromAST(parseValue('{ stars: 5, tags: ["featured"] }'), ReviewInput); // => { stars: 5, tags: ['featured'] }
valueFromAST(parseValue('{ stars: "bad" }'), ReviewInput); // => undefined

Example 2

// This variant resolves variable references from runtime values.
import { parseValue } from 'graphql/language';
import { GraphQLInt } from 'graphql/type';
import { valueFromAST } from 'graphql/utilities';

valueFromAST(parseValue('$stars'), GraphQLInt, { stars: 5 }); // => 5
valueFromAST(parseValue('$stars'), GraphQLInt, {}); // => undefined

Deprecated

use coerceInputLiteral() instead - will be removed in v18

function valueFromASTUntyped

valueFromASTUntyped: (
    valueNode: ValueNode,
    variables?: Maybe<ObjMap<unknown>>
) => unknown;

Produces a JavaScript value given a GraphQL Value AST.
Because no GraphQL type is provided, the returned JavaScript value reflects the provided GraphQL value AST.
| GraphQL Value | JavaScript Value | | -------------------- | ---------------- | | Input Object | Object | | List | Array | | Boolean | Boolean | | String / Enum | String | | Int / Float | Number | | Null | null |
Parameter valueNode
GraphQL value AST node to convert.
Parameter variables
Optional runtime variable values keyed by variable name.
Returns
JavaScript value represented by the GraphQL value AST.
Example 1
import { parseValue } from 'graphql/language'; import { valueFromASTUntyped } from 'graphql/utilities'; const value = valueFromASTUntyped(parseValue('[1, 2, 3]')); value; // => [1, 2, 3] valueFromASTUntyped(parseValue('$name'), { name: 'Ada' }); // => 'Ada'

function ValuesOfCorrectTypeRule

ValuesOfCorrectTypeRule: (context: ValidationContext) => ASTVisitor;

Value literals of correct type

A GraphQL document is only valid if all value literals are of the type expected at their position.

See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { ValuesOfCorrectTypeRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    count(limit: Int): Int
  }
`);

const invalidDocument = parse(`
  { count(limit: "many") }
`);
const invalidErrors = validate(schema, invalidDocument, [
  ValuesOfCorrectTypeRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  { count(limit: 1) }
`);
const validErrors = validate(schema, validDocument, [ValuesOfCorrectTypeRule]);

validErrors; // => []

function valueToLiteral

valueToLiteral: (
    value: unknown,
    type: GraphQLInputType
) => ConstValueNode | undefined;

Produces a GraphQL Value AST given a JavaScript value and a GraphQL type.

Scalar types are converted by calling the valueToLiteral method on that type, otherwise the default scalar valueToLiteral method is used, defined below.

Provided value is a non-coerced "input" value. This function does not perform any coercion, however it does perform validation. Provided values which are invalid for the given type will result in an undefined return value.

Parameter value

JavaScript value to convert.

Parameter type

GraphQL input type to convert the value against.

Returns

A GraphQL value AST, or undefined if the value is invalid.

Example 1

import { print } from 'graphql/language';
import {
  GraphQLInputObjectType,
  GraphQLInt,
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
} from 'graphql/type';
import { valueToLiteral } from 'graphql/utilities';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {
    stars: { type: new GraphQLNonNull(GraphQLInt) },
    tags: { type: new GraphQLList(GraphQLString) },
  },
});

const literal = valueToLiteral({ stars: 5, tags: ['featured'] }, ReviewInput);

print(literal); // => '{ stars: 5, tags: ["featured"] }'
valueToLiteral({ tags: ['missing stars'] }, ReviewInput); // => undefined

function VariablesAreInputTypesRule

VariablesAreInputTypesRule: (context: ValidationContext) => ASTVisitor;

Variables are input types

A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).

See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { VariablesAreInputTypesRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    field(arg: ID): String
  }

  type User {
    name: String
  }
`);

const invalidDocument = parse(`
  query ($user: User) { field(arg: "1") }
`);
const invalidErrors = validate(schema, invalidDocument, [
  VariablesAreInputTypesRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  query ($id: ID) { field(arg: $id) }
`);
const validErrors = validate(schema, validDocument, [
  VariablesAreInputTypesRule,
]);

validErrors; // => []

function VariablesInAllowedPositionRule

VariablesInAllowedPositionRule: (context: ValidationContext) => ASTVisitor;

Variables in allowed position

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

See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed

Parameter context

The validation context used while checking the document.

Returns

A visitor that reports validation errors for this rule.

Example 1

import { buildSchema, parse, validate } from 'graphql';
import { VariablesInAllowedPositionRule } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    field(arg: ID!): String
  }
`);

const invalidDocument = parse(`
  query ($id: String) { field(arg: $id) }
`);
const invalidErrors = validate(schema, invalidDocument, [
  VariablesInAllowedPositionRule,
]);

invalidErrors.length; // => 1

const validDocument = parse(`
  query ($id: ID!) { field(arg: $id) }
`);
const validErrors = validate(schema, validDocument, [
  VariablesInAllowedPositionRule,
]);

validErrors; // => []

function visit

visit: {
    <N extends ASTNode>(
        root: N,
        visitor: ASTVisitor,
        visitorKeys?: ASTVisitorKeyMap
    ): N;
    <R>(root: ASTNode, visitor: ASTReducer<R>, visitorKeys?: ASTVisitorKeyMap): R;
};

visit() will walk through an AST using a depth-first traversal, calling the visitor's enter function at each node in the traversal, and calling the leave function after visiting that node and all of its child nodes.

By returning different values from the enter and leave functions, the behavior of the visitor can be altered, including skipping over a sub-tree of the AST (by returning false), editing the AST by returning a value or null to remove the value, or to stop the whole traversal by returning BREAK.

When using visit() to edit an AST, the original AST will not be modified, and a new version of the AST with the changes applied will be returned from the visit function.

Parameter root

The AST node at which to start traversal.

Parameter visitor

The visitor or reducer functions to call while traversing.

Parameter visitorKeys

Optional map of child keys to visit for each AST node kind.

Returns

The original AST, an edited AST, or a reduced value depending on the visitor.

Example 1

// Return values control traversal: undefined makes no change, false skips
// a subtree, BREAK stops traversal, null removes a node, and any other
// value replaces the current node.
import { Kind, parse, print, visit } from 'graphql/language';

const document = parse('{ hero { name } }');
const editedAST = visit(document, {
  Field: (node) => {
    if (node.name.value === 'hero') {
      return {
        ...node,
        name: { kind: Kind.NAME, value: 'human' },
      };
    }
  },
});

print(editedAST); // => '{\n  human {\n    name\n  }\n}'

Example 2

// A named visitor function runs when entering nodes of that kind.
import { parse, visit } from 'graphql/language';

const document = parse('{ hero { name } }');
const fieldNames = [];

visit(document, {
  Field: (node) => {
    fieldNames.push(node.name.value);
  },
});

fieldNames; // => ['hero', 'name']

Example 3

// A named visitor object can provide separate enter and leave handlers for
// nodes of that kind.
import { parse, visit } from 'graphql/language';

const document = parse('{ hero { name } }');
const events = [];

visit(document, {
  Field: {
    enter: (node) => {
      events.push(`enter:${node.name.value}`);
    },
    leave: (node) => {
      events.push(`leave:${node.name.value}`);
    },
  },
});

events; // => ['enter:hero', 'enter:name', 'leave:name', 'leave:hero']

Example 4

// Generic enter and leave handlers run for every node.
import { parse, visit } from 'graphql/language';

const document = parse('{ hero { name } }');
let enterCount = 0;
let leaveCount = 0;

visit(document, {
  enter: (node) => {
    enterCount += 1;
  },
  leave: (node) => {
    leaveCount += 1;
  },
});

enterCount; // => leaveCount
enterCount > 0; // => true

Traverses an AST with reducer callbacks and returns the reduced value.

Parameter root

The AST node where traversal starts.

Parameter visitor

Reducer callbacks to invoke during traversal.

Parameter visitorKeys

Optional mapping of child keys for each AST node kind.

Returns

The value produced by the reducer visitor.

Example 1

// A reducer visitor returns values from leave handlers to build a reduced
// result instead of returning an edited AST.
import { parse, visit } from 'graphql/language';

const document = parse('{ hero { name } }');
const printed = visit(document, {
  Name: {
    leave: (node) => {
      return node.value;
    },
  },
  Field: {
    leave: (node) => {
      return node.selectionSet == null
        ? node.name
        : `${node.name} { ${node.selectionSet} }`;
    },
  },
  SelectionSet: {
    leave: (node) => {
      return node.selections.join(' ');
    },
  },
  OperationDefinition: {
    leave: (node) => {
      return node.selectionSet;
    },
  },
  Document: {
    leave: (node) => {
      return node.definitions.join('\n');
    },
  },
});

printed; // => 'hero { name }'

function visitInParallel

visitInParallel: (visitors: ReadonlyArray<ASTVisitor>) => ASTVisitor;

Creates a new visitor instance which delegates to many visitors to run in parallel. Each visitor will be visited for each node before moving on.

If a prior visitor edits a node, no following visitors will see that node.

Parameter visitors

The visitors to merge into one parallel visitor.

Returns

A visitor that delegates traversal to each provided visitor.

Example 1

import { parse, visit, visitInParallel } from 'graphql/language';

const document = parse('{ hero { name } }');
const events = [];

visit(
  document,
  visitInParallel([
    {
      Field: (node) => {
        events.push(`field:${node.name.value}`);
      },
    },
    {
      Name: (node) => {
        events.push(`name:${node.value}`);
      },
    },
  ]),
);

events; // => ['field:hero', 'name:hero', 'field:name', 'name:name']

function visitWithTypeInfo

visitWithTypeInfo: (typeInfo: TypeInfo, visitor: ASTVisitor) => ASTVisitor;

Creates a new visitor instance which maintains a provided TypeInfo instance along with visiting visitor.

Parameter typeInfo

TypeInfo instance to update during traversal.

Parameter visitor

Visitor callbacks to wrap with TypeInfo updates.

Returns

A visitor that keeps TypeInfo in sync while delegating callbacks.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const typeInfo = new TypeInfo(schema);
const fields = [];

visit(
  parse('{ greeting }'),
  visitWithTypeInfo(typeInfo, {
    Field: (node) => {
      fields.push({
        name: node.name.value,
        parentType: String(typeInfo.getParentType()),
        type: String(typeInfo.getType()),
      });
    },
  }),
);

fields; // => [{ name: 'greeting', parentType: 'Query', type: 'String' }]

Classes

class AbortedGraphQLExecutionError

class AbortedGraphQLExecutionError<TResult> extends Error {}

Error thrown when GraphQL execution is aborted.

constructor

constructor(reason: {}, result: PromiseOrValue<TResult>);

Creates an error for an aborted GraphQL execution.

Parameter reason

Abort reason used as the error cause.

Parameter result

Partial execution result available when execution stopped.

Example 1

import { AbortedGraphQLExecutionError } from 'graphql/execution';

const cause = new Error('Request cancelled.');
const partialResult = { data: { viewer: null } };
const error = new AbortedGraphQLExecutionError(cause, partialResult);

error.message; // => 'Request cancelled.'
error.cause; // => cause
error.abortedResult; // => partialResult

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property abortedResult

readonly abortedResult: PromiseOrValue<TResult>;

Partial execution result available when execution was aborted.

class GraphQLArgument

class GraphQLArgument implements GraphQLSchemaElement {}

A resolved GraphQL argument definition.

constructor

constructor(
    parent: GraphQLField<any, any, any> | GraphQLDirective,
    name: string,
    config: GraphQLArgumentConfig
);

Creates a resolved GraphQL argument definition.

Parameter parent

Field or directive that owns this argument.

Parameter name

Argument name.

Parameter config

Argument configuration.

Example 1

import {
  GraphQLArgument,
  GraphQLField,
  GraphQLObjectType,
  GraphQLString,
} from 'graphql/type';

const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
const arg = new GraphQLArgument(field, 'name', {
  type: GraphQLString,
  default: { value: 'world' },
});

arg.parent; // => field
arg.name; // => 'name'
arg.default.value; // => 'world'

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property astNode

astNode: InputValueDefinitionNode;

AST node from which this schema element was built, if available.

property default

default: GraphQLDefaultInput;

Default value represented as either a runtime value or a GraphQL literal.

property defaultValue

defaultValue: {};

Deprecated legacy default value used when no explicit value is supplied. Use default instead.
Deprecated
use default instead, defaultValue will be removed in v18

property deprecationReason

deprecationReason: string;

Reason this element is deprecated, if one was provided.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensions

extensions: Readonly<GraphQLArgumentExtensions>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property parent

parent: GraphQLField<any, any, any> | GraphQLDirective;

Field or directive that owns this argument.

property type

type: GraphQLInputType;

The GraphQL type reference or runtime type for this element.

method toConfig

toConfig: () => GraphQLArgumentNormalizedConfig;

Returns a normalized configuration object for this argument.

Returns

A configuration object that can be used to recreate this argument.

Example 1

import {
  GraphQLArgument,
  GraphQLField,
  GraphQLObjectType,
  GraphQLString,
} from 'graphql/type';

const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
const arg = new GraphQLArgument(field, 'name', {
  type: GraphQLString,
  default: { value: 'world' },
});

arg.toConfig().default.value; // => 'world'

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The argument coordinate.

Example 1

import {
  GraphQLArgument,
  GraphQLField,
  GraphQLObjectType,
  GraphQLString,
} from 'graphql/type';

const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
const arg = new GraphQLArgument(field, 'name', { type: GraphQLString });

JSON.stringify(arg); // => '"Query.greeting(name:)"'

method toString

toString: () => string;

Returns this argument as a schema coordinate string.

Returns

The argument coordinate.

Example 1

import {
  GraphQLArgument,
  GraphQLField,
  GraphQLObjectType,
  GraphQLString,
} from 'graphql/type';

const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });
const arg = new GraphQLArgument(field, 'name', { type: GraphQLString });

arg.toString(); // => 'Query.greeting(name:)'

class GraphQLDirective

class GraphQLDirective implements GraphQLSchemaElement {}

Directives are used by the GraphQL runtime as a way of modifying execution behavior. Type system creators will usually not create these directly.

constructor

constructor(config: Readonly<GraphQLDirectiveConfig>);

Creates a GraphQLDirective instance.

Parameter config

Configuration describing this object.

Example 1

import { DirectiveLocation, parse } from 'graphql/language';
import {
  GraphQLBoolean,
  GraphQLDirective,
  GraphQLInt,
  GraphQLNonNull,
} from 'graphql/type';

const document = parse(`
  directive @cacheControl(maxAge: Int) repeatable on FIELD_DEFINITION
  extend directive @cacheControl(maxAge: Int) on FIELD_DEFINITION
`);
const definition = document.definitions[0];

const cacheControl = new GraphQLDirective({
  name: 'cacheControl',
  description: 'Controls HTTP cache hints for a field.',
  locations: [DirectiveLocation.FIELD_DEFINITION],
  args: {
    inheritMaxAge: {
      description: 'Inherit the parent cache hint.',
      type: new GraphQLNonNull(GraphQLBoolean),
      default: { value: false },
      deprecationReason: 'Use maxAge instead.',
      extensions: { scope: 'cache' },
    },
    maxAge: {
      type: GraphQLInt,
      astNode: definition.arguments[0],
    },
  },
  isRepeatable: true,
  deprecationReason: 'Use @cache instead.',
  extensions: { scope: 'cache' },
  astNode: definition,
  extensionASTNodes: [document.definitions[1]],
});

cacheControl.name; // => 'cacheControl'
cacheControl.description; // => 'Controls HTTP cache hints for a field.'
cacheControl.args[0].name; // => 'inheritMaxAge'
cacheControl.args[0].default.value; // => false
cacheControl.isRepeatable; // => true
cacheControl.extensions; // => { scope: 'cache' }

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property args

args: readonly GraphQLArgument[];

Arguments accepted by this field or directive.

property astNode

astNode: DirectiveDefinitionNode;

AST node from which this schema element was built, if available.

property deprecationReason

deprecationReason: string;

Reason this element is deprecated, if one was provided.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes: readonly DirectiveExtensionNode[];

AST extension nodes applied to this schema element.

property extensions

extensions: Readonly<GraphQLDirectiveExtensions>;

Custom extension fields reserved for users.

property isRepeatable

isRepeatable: boolean;

Whether this directive may appear more than once at the same location.

property locations

locations: readonly DirectiveLocation[];

Locations where this directive may be applied.

property name

name: string;

The GraphQL name for this schema element.

method toConfig

toConfig: () => GraphQLDirectiveNormalizedConfig;

Returns a normalized configuration object for this object.

Returns

A configuration object that can be used to recreate this object.

Example 1

import { DirectiveLocation } from 'graphql/language';
import { GraphQLDirective, GraphQLString } from 'graphql/type';

const tag = new GraphQLDirective({
  name: 'tag',
  locations: [DirectiveLocation.FIELD_DEFINITION],
  args: {
    name: { type: GraphQLString },
  },
});

const config = tag.toConfig();
const tagCopy = new GraphQLDirective(config);

config.args.name.type; // => GraphQLString
tagCopy.args[0].name; // => 'name'

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import { DirectiveLocation } from 'graphql/language';
import { GraphQLDirective } from 'graphql/type';

const tag = new GraphQLDirective({
  name: 'tag',
  locations: [DirectiveLocation.FIELD_DEFINITION],
});

tag.toJSON(); // => '@tag'
JSON.stringify({ directive: tag }); // => '{"directive":"@tag"}'

method toString

toString: () => string;

Returns the schema coordinate identifying this directive.

Returns

The directive schema coordinate.

Example 1

import { DirectiveLocation } from 'graphql/language';
import { GraphQLDirective } from 'graphql/type';

const tag = new GraphQLDirective({
  name: 'tag',
  locations: [DirectiveLocation.FIELD_DEFINITION],
});

tag.toString(); // => '@tag'

class GraphQLEnumType

class GraphQLEnumType implements GraphQLSchemaElement {}

Enum Type Definition
Enum types define leaf values whose serialized form is one of a fixed set of GraphQL enum names. Internally, enum values can map to any runtime value, often integers.
Example 1
import { GraphQLEnumType } from 'graphql/type'; const RGBType = new GraphQLEnumType({ name: 'RGB', values: { RED: { value: 0 }, GREEN: { value: 1 }, BLUE: { value: 2 }, }, }); RGBType.getValue('GREEN')?.value; // => 1
Note: If a value is not provided in a definition, the name of the enum value will be used as its internal value.

constructor

constructor(config: Readonly<GraphQLEnumTypeConfig>);

Creates a GraphQLEnumType instance.

Parameter config

Configuration describing this object.

Example 1

import { parse } from 'graphql/language';
import { GraphQLEnumType } from 'graphql/type';

const document = parse(`
  enum Episode {
    NEW_HOPE
    EMPIRE
    JEDI
  }

  extend enum Episode {
    FORCE_AWAKENS
  }
`);
const definition = document.definitions[0];

const Episode = new GraphQLEnumType({
  name: 'Episode',
  description: 'A Star Wars film episode.',
  values: {
    NEW_HOPE: {
      value: 4,
      description: 'Released in 1977.',
      extensions: { trilogy: 'original' },
      astNode: definition.values[0],
    },
    EMPIRE: { value: 5, astNode: definition.values[1] },
    JEDI: {
      value: 6,
      deprecationReason: 'Use RETURN_OF_THE_JEDI.',
      astNode: definition.values[2],
    },
  },
  extensions: { catalog: 'films' },
  astNode: definition,
  extensionASTNodes: [document.definitions[1]],
});

Episode.description; // => 'A Star Wars film episode.'
Episode.coerceOutputValue(5); // => 'EMPIRE'
Episode.coerceInputValue('JEDI'); // => 6
Episode.getValue('JEDI').deprecationReason; // => 'Use RETURN_OF_THE_JEDI.'
Episode.extensions; // => { catalog: 'films' }

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property astNode

astNode: EnumTypeDefinitionNode;

AST node from which this schema element was built, if available.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes: readonly EnumTypeExtensionNode[];

AST extension nodes applied to this schema element.

property extensions

extensions: Readonly<GraphQLEnumTypeExtensions>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

method coerceInputLiteral

coerceInputLiteral: (
    valueNode: ConstValueNode,
    hideSuggestions?: Maybe<boolean>
) => Maybe<any>;

Coerces an enum value AST node to its internal runtime value.

Parameter valueNode

Enum value AST node to coerce.

Parameter hideSuggestions

Whether suggestion text should be omitted from errors.

Returns

The internal runtime value for the enum literal.

Example 1

import { parseConstValue } from 'graphql/language';
import { GraphQLEnumType } from 'graphql/type';

const RGB = new GraphQLEnumType({
  name: 'RGB',
  values: {
    RED: { value: 0 },
    GREEN: { value: 1 },
    BLUE: { value: 2 },
  },
});

RGB.coerceInputLiteral(parseConstValue('RED')); // => 0
RGB.coerceInputLiteral(parseConstValue('"RED"'), true); // throws an error

method coerceInputValue

coerceInputValue: (
    inputValue: unknown,
    hideSuggestions?: Maybe<boolean>
) => Maybe<any>;

Coerces an external enum name to its internal runtime value.

Parameter inputValue

External enum name to coerce.

Parameter hideSuggestions

Whether suggestion text should be omitted from errors.

Returns

The internal runtime value for the enum name.

Example 1

import { GraphQLEnumType } from 'graphql/type';

const RGB = new GraphQLEnumType({
  name: 'RGB',
  values: {
    RED: { value: 0 },
    GREEN: { value: 1 },
    BLUE: { value: 2 },
  },
});

RGB.coerceInputValue('BLUE'); // => 2
RGB.coerceInputValue('PURPLE'); // throws an error
RGB.coerceInputValue(2); // throws an error

method coerceOutputValue

coerceOutputValue: (outputValue: unknown) => Maybe<string>;

Coerces a runtime enum value to a GraphQL enum name.

Parameter outputValue

Runtime enum value to coerce.

Returns

The GraphQL enum name for the runtime value.

Example 1

import { GraphQLEnumType } from 'graphql/type';

const RGB = new GraphQLEnumType({
  name: 'RGB',
  values: {
    RED: { value: 0 },
    GREEN: { value: 1 },
    BLUE: { value: 2 },
  },
});

RGB.coerceOutputValue(1); // => 'GREEN'
RGB.coerceOutputValue(3); // throws an error

method getValue

getValue: (name: string) => Maybe<GraphQLEnumValue>;

Returns the enum value definition for a value name.

Parameter name

The GraphQL name to look up.

Returns

The matching enum value definition, if it exists.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertEnumType } from 'graphql/type';

const schema = buildSchema(`
  enum Episode {
    NEW_HOPE
    EMPIRE
  }

  type Query {
    episode: Episode
  }
`);

const Episode = assertEnumType(schema.getType('Episode'));

Episode.getValue('EMPIRE')?.name; // => 'EMPIRE'
Episode.getValue('JEDI'); // => undefined

method getValues

getValues: () => ReadonlyArray<GraphQLEnumValue>;

Returns the values defined by this enum type.

Returns

Enum value definitions in schema order.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertEnumType } from 'graphql/type';

const schema = buildSchema(`
  enum Episode {
    NEW_HOPE
    EMPIRE
    JEDI
  }

  type Query {
    episode: Episode
  }
`);

const Episode = assertEnumType(schema.getType('Episode'));

Episode.getValues().map((value) => value.name); // => ['NEW_HOPE', 'EMPIRE', 'JEDI']

method parseLiteral

parseLiteral: (
    valueNode: ValueNode,
    _variables: Maybe<ObjMap<unknown>>,
    hideSuggestions?: Maybe<boolean>
) => Maybe<any>;

Deprecated legacy enum parser for externally provided input literals. Use coerceInputLiteral() instead.
Parameter valueNode
Enum value AST node to parse.
Parameter _variables
Deprecated variable values parameter that is no longer used.
Parameter hideSuggestions
Whether suggestion text should be omitted from errors.
Returns
The internal runtime value for the enum literal.
Example 1
import { parseValue } from 'graphql/language'; import { GraphQLEnumType } from 'graphql/type'; const RGB = new GraphQLEnumType({ name: 'RGB', values: { RED: { value: 0 }, GREEN: { value: 1 }, BLUE: { value: 2 }, }, }); RGB.parseLiteral(parseValue('RED')); // => 0 RGB.parseLiteral(parseValue('"RED"')); // throws an error
Deprecated
use coerceInputLiteral() instead, parseLiteral() will be removed in v18

method parseValue

parseValue: (
    inputValue: unknown,
    hideSuggestions?: Maybe<boolean>
) => Maybe<any>;

Deprecated legacy enum parser for externally provided input values. Use coerceInputValue() instead.
Parameter inputValue
External enum name to parse.
Parameter hideSuggestions
Whether suggestion text should be omitted from errors.
Returns
The internal runtime value for the enum name.
Example 1
import { GraphQLEnumType } from 'graphql/type'; const RGB = new GraphQLEnumType({ name: 'RGB', values: { RED: { value: 0 }, GREEN: { value: 1 }, BLUE: { value: 2 }, }, }); RGB.parseValue('BLUE'); // => 2 RGB.parseValue('PURPLE', true); // throws an error
Deprecated
use coerceInputValue() instead, parseValue() will be removed in v18

method serialize

serialize: (outputValue: unknown) => Maybe<string>;

Serializes a runtime enum value as a GraphQL enum name.
Parameter outputValue
Runtime enum value to serialize.
Returns
The GraphQL enum name for the runtime value.
This deprecated method delegates to coerceOutputValue(); call coerceOutputValue() directly instead.
Example 1
import { GraphQLEnumType } from 'graphql/type'; const RGB = new GraphQLEnumType({ name: 'RGB', values: { RED: { value: 0 }, GREEN: { value: 1 }, BLUE: { value: 2 }, }, }); RGB.serialize(1); // => 'GREEN' RGB.serialize(3); // throws an error
Deprecated
use coerceOutputValue() instead, serialize() will be removed in v18

method toConfig

toConfig: () => GraphQLEnumTypeNormalizedConfig;

Returns a normalized configuration object for this object.

Returns

A configuration object that can be used to recreate this object.

Example 1

import { GraphQLEnumType } from 'graphql/type';

const RGB = new GraphQLEnumType({
  name: 'RGB',
  values: {
    RED: { value: 0 },
    GREEN: { value: 1 },
    BLUE: { value: 2 },
  },
});

const config = RGB.toConfig();
const RGBCopy = new GraphQLEnumType(config);

config.values.GREEN.value; // => 1
RGBCopy.coerceOutputValue(2); // => 'BLUE'

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import { GraphQLEnumType } from 'graphql/type';

const Episode = new GraphQLEnumType({
  name: 'Episode',
  values: {
    NEW_HOPE: {},
  },
});

Episode.toJSON(); // => 'Episode'
JSON.stringify({ type: Episode }); // => '{"type":"Episode"}'

method toString

toString: () => string;

Returns the schema coordinate identifying this enum type.

Returns

The schema coordinate for this enum type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertEnumType } from 'graphql/type';

const schema = buildSchema(`
  enum Episode {
    NEW_HOPE
  }

  type Query {
    episode: Episode
  }
`);

const Episode = assertEnumType(schema.getType('Episode'));

Episode.toString(); // => 'Episode'

method valueToLiteral

valueToLiteral: (value: unknown) => ConstValueNode | undefined;

Converts a runtime enum value to a GraphQL enum value AST node.

Parameter value

Runtime enum value to convert.

Returns

Enum value AST node, or undefined if the value is invalid.

Example 1

import { print } from 'graphql/language';
import { GraphQLEnumType } from 'graphql/type';

const RGB = new GraphQLEnumType({
  name: 'RGB',
  values: {
    RED: { value: 0 },
    GREEN: { value: 1 },
    BLUE: { value: 2 },
  },
});

print(RGB.valueToLiteral(2)); // => 'BLUE'
RGB.valueToLiteral(3); // => undefined

class GraphQLEnumValue

class GraphQLEnumValue implements GraphQLSchemaElement {}

A resolved GraphQL enum value definition.

constructor

constructor(
    parentEnum: GraphQLEnumType,
    name: string,
    config: GraphQLEnumValueConfig
);

Creates a resolved GraphQL enum value definition.

Parameter parentEnum

Enum type that owns this enum value.

Parameter name

Enum value name.

Parameter config

Enum value configuration.

Example 1

import { GraphQLEnumType, GraphQLEnumValue } from 'graphql/type';

const Episode = new GraphQLEnumType({
  name: 'Episode',
  values: { NEW_HOPE: { value: 4 } },
});
const enumValue = new GraphQLEnumValue(Episode, 'EMPIRE', {
  value: 5,
  description: 'Released in 1980.',
});

enumValue.parentEnum; // => Episode
enumValue.name; // => 'EMPIRE'
enumValue.value; // => 5

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property astNode

astNode: EnumValueDefinitionNode;

AST node from which this schema element was built, if available.

property deprecationReason

deprecationReason: string;

Reason this element is deprecated, if one was provided.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensions

extensions: Readonly<GraphQLEnumValueExtensions>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property parentEnum

parentEnum: GraphQLEnumType;

Enum type that owns this enum value.

property value

value: any;

Parsed value represented by this node.

method toConfig

toConfig: () => GraphQLEnumValueNormalizedConfig;

Returns a normalized configuration object for this enum value.

Returns

A configuration object that can be used to recreate this enum value.

Example 1

import { GraphQLEnumType, GraphQLEnumValue } from 'graphql/type';

const Episode = new GraphQLEnumType({
  name: 'Episode',
  values: { NEW_HOPE: { value: 4 } },
});
const enumValue = new GraphQLEnumValue(Episode, 'EMPIRE', {
  value: 5,
  extensions: { trilogy: 'original' },
});

enumValue.toConfig(); // => { description: undefined, value: 5, deprecationReason: undefined, extensions: { trilogy: 'original' }, astNode: undefined }

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

Enum value coordinate.

Example 1

import { GraphQLEnumType, GraphQLEnumValue } from 'graphql/type';

const Episode = new GraphQLEnumType({
  name: 'Episode',
  values: { NEW_HOPE: { value: 4 } },
});
const enumValue = new GraphQLEnumValue(Episode, 'EMPIRE', { value: 5 });

JSON.stringify(enumValue); // => '"Episode.EMPIRE"'

method toString

toString: () => string;

Returns this enum value as a schema coordinate string.

Returns

Enum value coordinate.

Example 1

import { GraphQLEnumType, GraphQLEnumValue } from 'graphql/type';

const Episode = new GraphQLEnumType({
  name: 'Episode',
  values: { NEW_HOPE: { value: 4 } },
});
const enumValue = new GraphQLEnumValue(Episode, 'EMPIRE', { value: 5 });

enumValue.toString(); // => 'Episode.EMPIRE'

class GraphQLError

class GraphQLError extends Error {}

A GraphQLError describes an Error found during the parse, validate, or execute phases of performing a GraphQL operation. In addition to a message and stack trace, it also includes information about the locations in a GraphQL document and/or execution result that correspond to the Error.

constructor

constructor(message: string, options?: GraphQLErrorOptions);

Creates a GraphQLError instance.

Parameter message

Human-readable error message.

Parameter options

Error metadata such as source locations, response path, cause, original error, and extensions.

Example 1

// Create an error from AST nodes and response metadata.
import { parse } from 'graphql/language';
import { GraphQLError } from 'graphql/error';

const document = parse('{ greeting }');
const fieldNode = document.definitions[0].selectionSet.selections[0];
const error = new GraphQLError('Cannot query this field.', {
  nodes: fieldNode,
  path: ['greeting'],
  extensions: { code: 'FORBIDDEN' },
});

error.message; // => 'Cannot query this field.'
error.locations; // => [{ line: 1, column: 3 }]
error.path; // => ['greeting']
error.extensions; // => { code: 'FORBIDDEN' }

Example 2

// This variant derives locations from source positions and preserves the cause.
import { Source } from 'graphql/language';
import { GraphQLError } from 'graphql/error';

const source = new Source('{ greeting }');
const cause = new Error('Database unavailable.');
const error = new GraphQLError('Resolver failed.', {
  source,
  positions: [2],
  path: ['greeting'],
  cause,
});

error.locations; // => [{ line: 1, column: 3 }]
error.path; // => ['greeting']
error.cause; // => cause

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property extensions

readonly extensions: GraphQLErrorExtensions;

Extension fields to add to the formatted error.

property locations

readonly locations: readonly SourceLocation[];

An array of { line, column } locations within the source GraphQL document which correspond to this error.
Errors during validation often contain multiple locations, for example to point out two things with the same name. Errors during execution include a single location, the field which produced the error.
Enumerable, and appears in the result of JSON.stringify().

property nodes

readonly nodes: readonly ASTNode[];

An array of GraphQL AST Nodes corresponding to this error.

property originalError

readonly originalError: Error;

Original error that caused this GraphQLError, if one exists. Deprecated in favor of cause to better align with JavaScript standards.
Deprecated
Use cause instead.

property path

readonly path: readonly (string | number)[];

An array describing the JSON-path into the execution response which corresponds to this error. Only included for errors during execution.
Enumerable, and appears in the result of JSON.stringify().

property positions

readonly positions: readonly number[];

An array of character offsets within the source GraphQL document which correspond to this error.

property source

readonly source: Source;

The source GraphQL document for the first location of this error.
Note that if this Error represents more than one node, the source may not represent nodes after the first node.

method toJSON

toJSON: () => GraphQLFormattedError;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import { GraphQLError } from 'graphql/error';

const error = new GraphQLError('Resolver failed.', {
  path: ['viewer', 'name'],
  extensions: { code: 'INTERNAL' },
});

error.toJSON(); // => { message: 'Resolver failed.', path: ['viewer', 'name'], extensions: { code: 'INTERNAL' } }

method toString

toString: () => string;

Returns this error as a human-readable message with source locations.

Returns

The formatted error string.

Example 1

import { Source } from 'graphql/language';
import { GraphQLError } from 'graphql/error';

const error = new GraphQLError('Cannot query field "name".', {
  source: new Source('{ name }'),
  positions: [2],
});

error.toString(); // => 'Cannot query field "name".\n\nGraphQL request:1:3\n1 | { name }\n  |   ^'

class GraphQLField

class GraphQLField<TSource = any, TContext = any, TArgs = any>
    implements GraphQLSchemaElement {}

A resolved GraphQL field definition.

constructor

constructor(
    parentType:
        | GraphQLObjectType<TSource, TContext, any>
        | GraphQLInterfaceType<TSource, TContext>,
    name: string,
    config: GraphQLFieldConfig<TSource, TContext, TArgs>
);

Creates a resolved GraphQL field definition.

Parameter parentType

Object or interface type that owns this field, if known.

Parameter name

Field name.

Parameter config

Field configuration.

Example 1

import { parse } from 'graphql/language';
import { GraphQLField, GraphQLObjectType, GraphQLString } from 'graphql/type';

const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
const document = parse('type Query { greeting: String }');
const fieldNode = document.definitions[0].fields[0];
const field = new GraphQLField(Query, 'greeting', {
  description: 'Greeting text.',
  type: GraphQLString,
  args: {
    name: { type: GraphQLString, default: { value: 'world' } },
  },
  resolve: (_source, { name }) => `Hello, ${name}!`,
  subscribe: async function* () {
    yield { greeting: 'Hello!' };
  },
  deprecationReason: 'Use hello.',
  extensions: { cacheSeconds: 60 },
  astNode: fieldNode,
});

field.parentType; // => Query
field.name; // => 'greeting'
field.args[0].default.value; // => 'world'
typeof field.subscribe; // => 'function'
field.deprecationReason; // => 'Use hello.'
field.astNode; // => fieldNode

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property args

args: readonly GraphQLArgument[];

Arguments accepted by this field or directive.

property astNode

astNode: FieldDefinitionNode;

AST node from which this schema element was built, if available.

property deprecationReason

deprecationReason: string;

Reason this element is deprecated, if one was provided.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensions

extensions: Readonly<GraphQLFieldExtensions<TSource, TContext, TArgs>>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property parentType

parentType:
    | GraphQLObjectType<TSource, TContext, any>
    | GraphQLInterfaceType<TSource, TContext>;

Object or interface type that owns this field, if known.

property resolve

resolve?: GraphQLFieldResolver<TSource, TContext, TArgs, unknown>;

Resolver function used to produce this field value.

subscribe?: GraphQLFieldResolver<TSource, TContext, TArgs, unknown>;

Resolver function used to create a subscription event stream for this field.

property type

type: GraphQLOutputType;

The GraphQL type reference or runtime type for this element.

method toConfig

toConfig: () => GraphQLFieldNormalizedConfig<TSource, TContext, TArgs>;

Returns a normalized configuration object for this field.

Returns

A configuration object that can be used to recreate this field.

Example 1

import { GraphQLField, GraphQLObjectType, GraphQLString } from 'graphql/type';

const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
const field = new GraphQLField(Query, 'greeting', {
  type: GraphQLString,
  extensions: { cacheSeconds: 60 },
});

field.toConfig().type; // => GraphQLString
field.toConfig().extensions; // => { cacheSeconds: 60 }

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The field coordinate.

Example 1

import { GraphQLField, GraphQLObjectType, GraphQLString } from 'graphql/type';

const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });

JSON.stringify(field); // => '"Query.greeting"'

method toString

toString: () => string;

Returns this field as a schema coordinate string.

Returns

The field coordinate.

Example 1

import { GraphQLField, GraphQLObjectType, GraphQLString } from 'graphql/type';

const Query = new GraphQLObjectType({ name: 'Query', fields: {} });
const field = new GraphQLField(Query, 'greeting', { type: GraphQLString });

field.toString(); // => 'Query.greeting'

class GraphQLInputField

class GraphQLInputField implements GraphQLSchemaElement {}

A resolved GraphQL input field definition.

constructor

constructor(
    parentType: GraphQLInputObjectType,
    name: string,
    config: GraphQLInputFieldConfig
);

Creates a resolved GraphQL input field definition.

Parameter parentType

Input object type that owns this field.

Parameter name

Input field name.

Parameter config

Input field configuration.

Example 1

import {
  GraphQLInputField,
  GraphQLInputObjectType,
  GraphQLString,
} from 'graphql/type';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {},
});
const field = new GraphQLInputField(ReviewInput, 'commentary', {
  type: GraphQLString,
  default: { value: '' },
});

field.parentType; // => ReviewInput
field.name; // => 'commentary'
field.default.value; // => ''

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property astNode

astNode: InputValueDefinitionNode;

AST node from which this schema element was built, if available.

property default

default: GraphQLDefaultInput;

Default value represented as either a runtime value or a GraphQL literal.

property defaultValue

defaultValue: {};

Deprecated legacy default value used when no explicit value is supplied. Use default instead.
Deprecated
use default instead, defaultValue will be removed in v18

property deprecationReason

deprecationReason: string;

Reason this element is deprecated, if one was provided.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensions

extensions: Readonly<GraphQLInputFieldExtensions>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property parentType

parentType: GraphQLInputObjectType;

Input object type that owns this input field.

property type

type: GraphQLInputType;

The GraphQL type reference or runtime type for this element.

method toConfig

toConfig: () => GraphQLInputFieldNormalizedConfig;

Returns a normalized configuration object for this input field.

Returns

A configuration object that can be used to recreate this input field.

Example 1

import {
  GraphQLInputField,
  GraphQLInputObjectType,
  GraphQLString,
} from 'graphql/type';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {},
});
const field = new GraphQLInputField(ReviewInput, 'commentary', {
  type: GraphQLString,
  extensions: { form: 'review' },
});

field.toConfig().extensions; // => { form: 'review' }

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The input field coordinate.

Example 1

import {
  GraphQLInputField,
  GraphQLInputObjectType,
  GraphQLString,
} from 'graphql/type';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {},
});
const field = new GraphQLInputField(ReviewInput, 'commentary', {
  type: GraphQLString,
});

JSON.stringify(field); // => '"ReviewInput.commentary"'

method toString

toString: () => string;

Returns this input field as a schema coordinate string.

Returns

The input field coordinate.

Example 1

import {
  GraphQLInputField,
  GraphQLInputObjectType,
  GraphQLString,
} from 'graphql/type';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {},
});
const field = new GraphQLInputField(ReviewInput, 'commentary', {
  type: GraphQLString,
});

field.toString(); // => 'ReviewInput.commentary'

class GraphQLInputObjectType

class GraphQLInputObjectType implements GraphQLSchemaElement {}

Input Object Type Definition

An input object defines a structured collection of fields which may be supplied to a field argument.

Using NonNull will ensure that a value must be provided by the query

Example 1

const GeoPoint = new GraphQLInputObjectType({
  name: 'GeoPoint',
  fields: {
    lat: { type: new GraphQLNonNull(GraphQLFloat) },
    lon: { type: new GraphQLNonNull(GraphQLFloat) },
    alt: { type: GraphQLFloat, default: { value: 0 } },
  },
});

constructor

constructor(config: Readonly<GraphQLInputObjectTypeConfig>);

Creates a GraphQLInputObjectType instance.

Parameter config

Configuration describing this object.

Example 1

import { parse } from 'graphql/language';
import {
  GraphQLID,
  GraphQLInputObjectType,
  GraphQLInt,
  GraphQLNonNull,
  GraphQLString,
} from 'graphql/type';

const document = parse(`
  input ReviewInput {
    stars: Int!
    commentary: String
  }

  extend input ReviewInput {
    body: String
  }
`);
const definition = document.definitions[0];

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  description: 'Input collected when reviewing a product.',
  fields: {
    stars: {
      description: 'Star rating from one to five.',
      type: new GraphQLNonNull(GraphQLInt),
      extensions: { min: 1, max: 5 },
      astNode: definition.fields[0],
    },
    commentary: {
      type: GraphQLString,
      default: { value: '' },
      deprecationReason: 'Use body.',
      astNode: definition.fields[1],
    },
  },
  extensions: { form: 'review' },
  astNode: definition,
  extensionASTNodes: [document.definitions[1]],
  isOneOf: false,
});
const SearchBy = new GraphQLInputObjectType({
  name: 'SearchBy',
  fields: {
    id: { type: GraphQLID },
    slug: { type: GraphQLString },
  },
  isOneOf: true,
});

const fields = ReviewInput.getFields();

ReviewInput.description; // => 'Input collected when reviewing a product.'
String(fields.stars.type); // => 'Int!'
fields.stars.extensions; // => { min: 1, max: 5 }
fields.commentary.default.value; // => ''
fields.commentary.deprecationReason; // => 'Use body.'
ReviewInput.isOneOf; // => false
SearchBy.isOneOf; // => true

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property astNode

astNode: InputObjectTypeDefinitionNode;

AST node from which this schema element was built, if available.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes: readonly InputObjectTypeExtensionNode[];

AST extension nodes applied to this schema element.

property extensions

extensions: Readonly<GraphQLInputObjectTypeExtensions>;

Custom extension fields reserved for users.

property isOneOf

isOneOf: boolean;

Whether this input object uses the experimental OneOf input object semantics.

property name

name: string;

The GraphQL name for this schema element.

method getFields

getFields: () => GraphQLInputFieldMap;

Returns the fields defined by this type.

Returns

The fields keyed by field name.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInputObjectType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
    commentary: String = ""
  }

  type Query {
    reviews(filter: ReviewInput): [String]
  }
`);

const ReviewInput = assertInputObjectType(schema.getType('ReviewInput'));
const fields = ReviewInput.getFields();

Object.keys(fields); // => ['stars', 'commentary']
fields.commentary.default; // => { literal: { kind: 'StringValue', value: '' } }

method toConfig

toConfig: () => GraphQLInputObjectTypeNormalizedConfig;

Returns a normalized configuration object for this object.

Returns

A configuration object that can be used to recreate this object.

Example 1

import {
  GraphQLInputObjectType,
  GraphQLInt,
  GraphQLNonNull,
} from 'graphql/type';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {
    stars: { type: new GraphQLNonNull(GraphQLInt) },
  },
});

const config = ReviewInput.toConfig();
const ReviewInputCopy = new GraphQLInputObjectType(config);

String(config.fields.stars.type); // => 'Int!'
String(ReviewInputCopy.getFields().stars.type); // => 'Int!'

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import { GraphQLInputObjectType, GraphQLString } from 'graphql/type';

const ReviewInput = new GraphQLInputObjectType({
  name: 'ReviewInput',
  fields: {
    commentary: { type: GraphQLString },
  },
});

ReviewInput.toJSON(); // => 'ReviewInput'
JSON.stringify({ type: ReviewInput }); // => '{"type":"ReviewInput"}'

method toString

toString: () => string;

Returns the schema coordinate identifying this input object type.

Returns

The schema coordinate for this input object type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInputObjectType } from 'graphql/type';

const schema = buildSchema(`
  input ReviewInput {
    stars: Int!
  }

  type Query {
    reviews(filter: ReviewInput): [String]
  }
`);

const ReviewInput = assertInputObjectType(schema.getType('ReviewInput'));

ReviewInput.toString(); // => 'ReviewInput'

class GraphQLInterfaceType

class GraphQLInterfaceType<TSource = any, TContext = any>
    implements GraphQLSchemaElement {}

Interface Type Definition
When a field can return one of a heterogeneous set of types, a Interface type is used to describe what types are possible, what fields are in common across all types, as well as a function to determine which type is actually used when the field is resolved.
Example 1
const EntityType = new GraphQLInterfaceType({ name: 'Entity', fields: { name: { type: GraphQLString }, }, });

constructor

constructor(config: Readonly<GraphQLInterfaceTypeConfig<TSource, TContext>>);

Creates a GraphQLInterfaceType instance.

Parameter config

Configuration describing this object.

Example 1

import { parse } from 'graphql/language';
import { GraphQLID, GraphQLInterfaceType, GraphQLNonNull } from 'graphql/type';

const document = parse(`
  interface Node {
    id: ID!
  }

  interface Resource implements Node {
    id: ID!
  }

  extend interface Resource {
    url: String
  }
`);

const Node = new GraphQLInterfaceType({
  name: 'Node',
  fields: {
    id: { type: new GraphQLNonNull(GraphQLID) },
  },
});

const Resource = new GraphQLInterfaceType({
  name: 'Resource',
  description: 'An addressable resource.',
  interfaces: [Node],
  fields: {
    id: { type: new GraphQLNonNull(GraphQLID) },
  },
  resolveType: (value) => {
    return typeof value === 'object' && value != null && 'url' in value
      ? 'WebPage'
      : null;
  },
  extensions: { abstract: true },
  astNode: document.definitions[1],
  extensionASTNodes: [document.definitions[2]],
});

Resource.name; // => 'Resource'
Resource.getInterfaces(); // => [Node]
Object.keys(Resource.getFields()); // => ['id']
Resource.extensions; // => { abstract: true }

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property astNode

astNode: InterfaceTypeDefinitionNode;

AST node from which this schema element was built, if available.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes: readonly InterfaceTypeExtensionNode[];

AST extension nodes applied to this schema element.

property extensions

extensions: Readonly<GraphQLInterfaceTypeExtensions>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property resolveType

resolveType: GraphQLTypeResolver<TSource, TContext>;

Function that resolves the concrete object type for this abstract type.

method getFields

getFields: () => GraphQLFieldMap<TSource, TContext>;

Returns the fields defined by this type.

Returns

The fields keyed by field name.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInterfaceType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Query {
    node: Node
  }
`);

const Node = assertInterfaceType(schema.getType('Node'));
const fields = Node.getFields();

Object.keys(fields); // => ['id']
String(fields.id.type); // => 'ID!'

method getInterfaces

getInterfaces: () => ReadonlyArray<GraphQLInterfaceType>;

Returns the interfaces implemented by this type.

Returns

The implemented interfaces.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInterfaceType } from 'graphql/type';

const schema = buildSchema(`
  interface Resource {
    url: String!
  }

  interface Image implements Resource {
    url: String!
    width: Int
  }

  type Photo implements Resource & Image {
    url: String!
    width: Int
  }

  type Query {
    image: Image
  }
`);

const Image = assertInterfaceType(schema.getType('Image'));

Image.getInterfaces().map((type) => type.name); // => ['Resource']

method toConfig

toConfig: () => GraphQLInterfaceTypeNormalizedConfig<TSource, TContext>;

Returns a normalized configuration object for this object.

Returns

A configuration object that can be used to recreate this object.

Example 1

import { GraphQLID, GraphQLInterfaceType, GraphQLNonNull } from 'graphql/type';

const Node = new GraphQLInterfaceType({
  name: 'Node',
  fields: {
    id: { type: new GraphQLNonNull(GraphQLID) },
  },
});

const config = Node.toConfig();
const NodeCopy = new GraphQLInterfaceType(config);

String(config.fields.id.type); // => 'ID!'
String(NodeCopy.getFields().id.type); // => 'ID!'

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import { GraphQLInterfaceType, GraphQLString } from 'graphql/type';

const Named = new GraphQLInterfaceType({
  name: 'Named',
  fields: { name: { type: GraphQLString } },
});

Named.toJSON(); // => 'Named'
JSON.stringify({ type: Named }); // => '{"type":"Named"}'

method toString

toString: () => string;

Returns the schema coordinate identifying this interface type.

Returns

The schema coordinate for this interface type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInterfaceType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Query {
    node: Node
  }
`);

const Node = assertInterfaceType(schema.getType('Node'));

Node.toString(); // => 'Node'

class GraphQLList

class GraphQLList<T extends GraphQLType> implements GraphQLSchemaElement {}

List Type Wrapper

A list is a wrapping type which points to another type. Lists are often created within the context of defining the fields of an object type.

Example 1

const PersonType = new GraphQLObjectType({
  name: 'Person',
  fields: () => ({
    parents: { type: new GraphQLList(PersonType) },
    children: { type: new GraphQLList(PersonType) },
  }),
});

constructor

constructor(ofType: GraphQLType);

Creates a GraphQLList instance.

Parameter ofType

The type to wrap.

Example 1

import { GraphQLList, GraphQLString } from 'graphql/type';

const stringList = new GraphQLList(GraphQLString);

stringList.ofType; // => GraphQLString
String(stringList); // => '[String]'

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property ofType

readonly ofType: GraphQLType;

The type wrapped by this list or non-null type.

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import { GraphQLList, GraphQLString } from 'graphql/type';

const stringList = new GraphQLList(GraphQLString);

stringList.toJSON(); // => '[String]'
JSON.stringify({ type: stringList }); // => '{"type":"[String]"}'

method toString

toString: () => string;

Returns this wrapping type as a GraphQL type-reference string.

Returns

The GraphQL type-reference string.

Example 1

import { GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql/type';

const stringList = new GraphQLList(GraphQLString);
const requiredStringList = new GraphQLList(new GraphQLNonNull(GraphQLString));

stringList.toString(); // => '[String]'
requiredStringList.toString(); // => '[String!]'

class GraphQLNonNull

class GraphQLNonNull<T extends GraphQLNullableType>
    implements GraphQLSchemaElement {}

Non-Null Type Wrapper
A non-null is a wrapping type which points to another type. Non-null types enforce that their values are never null and can ensure an error is raised if this ever occurs during a request. It is useful for fields which you can make a strong guarantee on non-nullability, for example usually the id field of a database row will never be null.
Example 1
const RowType = new GraphQLObjectType({ name: 'Row', fields: () => ({ id: { type: new GraphQLNonNull(GraphQLString) }, }), });
Note: the enforcement of non-nullability occurs within the executor.

constructor

constructor(ofType: GraphQLNullableType);

Creates a GraphQLNonNull instance.

Parameter ofType

The type to wrap.

Example 1

import { GraphQLNonNull, GraphQLString } from 'graphql/type';

const requiredString = new GraphQLNonNull(GraphQLString);

requiredString.ofType; // => GraphQLString
String(requiredString); // => 'String!'

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property ofType

readonly ofType: GraphQLNullableType;

The type wrapped by this list or non-null type.

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import { GraphQLNonNull, GraphQLString } from 'graphql/type';

const requiredString = new GraphQLNonNull(GraphQLString);

requiredString.toJSON(); // => 'String!'
JSON.stringify({ type: requiredString }); // => '{"type":"String!"}'

method toString

toString: () => string;

Returns this wrapping type as a GraphQL type-reference string.

Returns

The GraphQL type-reference string.

Example 1

import { GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql/type';

const requiredString = new GraphQLNonNull(GraphQLString);
const requiredStringList = new GraphQLNonNull(new GraphQLList(GraphQLString));

requiredString.toString(); // => 'String!'
requiredStringList.toString(); // => '[String]!'

class GraphQLObjectType

class GraphQLObjectType<TSource = any, TContext = any, TAbstract = any>
    implements GraphQLSchemaElement {}

Object Type Definition

Almost all of the GraphQL types you define will be object types. Object types have a name, but most importantly describe their fields.

Example 1

const AddressType = new GraphQLObjectType({
  name: 'Address',
  fields: {
    street: { type: GraphQLString },
    number: { type: GraphQLInt },
    formatted: {
      type: GraphQLString,
      resolve: (obj) => {
        return obj.number + ' ' + obj.street;
      },
    },
  },
});

Example 2

When two types need to refer to each other, or a type needs to refer to itself in a field, you can use a function expression (aka a closure or a thunk) to supply the fields lazily.

const PersonType = new GraphQLObjectType({
  name: 'Person',
  fields: () => ({
    name: { type: GraphQLString },
    bestFriend: { type: PersonType },
  }),
});

constructor

constructor(
    config: Readonly<GraphQLObjectTypeConfig<TSource, TContext, TAbstract>>
);

Creates a GraphQLObjectType instance.

Parameter config

Configuration describing this object.

Example 1

// Configure an object type with interfaces, fields, arguments, and metadata.
import { parse } from 'graphql/language';
import {
  GraphQLID,
  GraphQLInterfaceType,
  GraphQLNonNull,
  GraphQLObjectType,
  GraphQLString,
} from 'graphql/type';

const document = parse(`
  type User implements Node {
    id: ID!
    name(format: String = "short"): String
  }

  extend type User {
    displayName: String
  }
`);
const definition = document.definitions[0];
const nameField = definition.fields[1];
const formatArg = nameField.arguments[0];

const Node = new GraphQLInterfaceType({
  name: 'Node',
  fields: {
    id: { type: new GraphQLNonNull(GraphQLID) },
  },
});

const User = new GraphQLObjectType({
  name: 'User',
  description: 'A registered user.',
  interfaces: [Node],
  fields: {
    id: { type: new GraphQLNonNull(GraphQLID) },
    name: {
      description: 'The formatted user name.',
      type: GraphQLString,
      args: {
        format: {
          description: 'Controls the name format.',
          type: GraphQLString,
          default: { value: 'short' },
          deprecationReason: 'Use locale instead.',
          extensions: { public: true },
          astNode: formatArg,
        },
      },
      resolve: (user, { format }) => {
        return format === 'long' ? user.fullName : user.name;
      },
      deprecationReason: 'Use displayName.',
      extensions: { cacheSeconds: 60 },
      astNode: nameField,
    },
  },
  isTypeOf: (value) => {
    return typeof value === 'object' && value != null && 'id' in value;
  },
  extensions: { entity: 'User' },
  astNode: definition,
  extensionASTNodes: [document.definitions[1]],
});

User.name; // => 'User'
User.getInterfaces(); // => [Node]
Object.keys(User.getFields()); // => ['id', 'name']
User.getFields().name.args[0].default.value; // => 'short'
User.extensions; // => { entity: 'User' }

Example 2

// This variant configures a subscription field with subscribe and resolve functions.
import { GraphQLObjectType, GraphQLString } from 'graphql/type';

const Subscription = new GraphQLObjectType({
  name: 'Subscription',
  fields: {
    greeting: {
      type: GraphQLString,
      subscribe: async function* () {
        yield { greeting: 'Hello!' };
      },
      resolve: (event) => {
        return event.greeting;
      },
    },
  },
});

typeof Subscription.getFields().greeting.subscribe; // => 'function'

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property astNode

astNode: ObjectTypeDefinitionNode;

AST node from which this schema element was built, if available.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes: readonly ObjectTypeExtensionNode[];

AST extension nodes applied to this schema element.

property extensions

extensions: Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>;

Custom extension fields reserved for users.

property isTypeOf

isTypeOf: GraphQLIsTypeOfFn<TAbstract, TContext>;

Predicate used to determine whether a runtime value belongs to this object type.

property name

name: string;

The GraphQL name for this schema element.

method getFields

getFields: () => GraphQLFieldMap<TSource, TContext>;

Returns the fields defined by this type.

Returns

The fields keyed by field name.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertObjectType } from 'graphql/type';

const schema = buildSchema(`
  type User {
    id: ID!
    name: String
  }

  type Query {
    viewer: User
  }
`);

const User = assertObjectType(schema.getType('User'));
const fields = User.getFields();

Object.keys(fields); // => ['id', 'name']
String(fields.id.type); // => 'ID!'

method getInterfaces

getInterfaces: () => ReadonlyArray<GraphQLInterfaceType>;

Returns the interfaces implemented by this type.

Returns

The implemented interfaces.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertObjectType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Query {
    viewer: User
  }
`);

const User = assertObjectType(schema.getType('User'));

User.getInterfaces().map((type) => type.name); // => ['Node']

method toConfig

toConfig: () => GraphQLObjectTypeNormalizedConfig<TSource, TContext, TAbstract>;

Returns a normalized configuration object for this object.

Returns

A configuration object that can be used to recreate this object.

Example 1

import { GraphQLObjectType, GraphQLString } from 'graphql/type';

const User = new GraphQLObjectType({
  name: 'User',
  fields: {
    name: { type: GraphQLString },
  },
});

const config = User.toConfig();
const UserCopy = new GraphQLObjectType(config);

config.fields.name.type; // => GraphQLString
UserCopy.getFields().name.type; // => GraphQLString

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import { GraphQLObjectType, GraphQLString } from 'graphql/type';

const User = new GraphQLObjectType({
  name: 'User',
  fields: { name: { type: GraphQLString } },
});

User.toJSON(); // => 'User'
JSON.stringify({ type: User }); // => '{"type":"User"}'

method toString

toString: () => string;

Returns the schema coordinate identifying this object type.

Returns

The schema coordinate for this object type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertObjectType } from 'graphql/type';

const schema = buildSchema(`
  type User {
    name: String
  }

  type Query {
    viewer: User
  }
`);

const User = assertObjectType(schema.getType('User'));

User.toString(); // => 'User'

class GraphQLScalarType

class GraphQLScalarType<TInternal = unknown, TExternal = TInternal>
    implements GraphQLSchemaElement {}

Scalar Type Definition
Scalar types define the leaf values of a GraphQL response and the input values accepted by arguments and input object fields. A scalar type has a name and coercion functions that validate and convert runtime values and GraphQL literals.
If a type's coerceOutputValue function returns null or does not return a value (i.e. it returns undefined) then an error will be raised and a null value will be returned in the response. Prefer validating inputs before execution so clients receive input diagnostics before result coercion fails. Custom scalar behavior is defined via the following functions:
- coerceOutputValue(value): Implements "Result Coercion". Given an internal value, produces an external value valid for this type. Returns undefined or throws an error to indicate invalid values.
- coerceInputValue(value): Implements "Input Coercion" for values. Given an external value (for example, variable values), produces an internal value valid for this type. Returns undefined or throws an error to indicate invalid values.
- coerceInputLiteral(ast): Implements "Input Coercion" for constant literals. Given a GraphQL literal (AST) (for example, an argument value), produces an internal value valid for this type. Returns undefined or throws an error to indicate invalid values.
- valueToLiteral(value): Converts an external value to a GraphQL literal (AST). Returns undefined or throws an error to indicate invalid values.
Deprecated, to be removed in v18:
- serialize(value): Implements "Result Coercion". Renamed to coerceOutputValue().
- parseValue(value): Implements "Input Coercion" for values. Renamed to coerceInputValue().
- parseLiteral(ast): Implements "Input Coercion" for literals including non-specified replacement of variables embedded within complex scalars. Replaced by the combination of the replaceVariables() utility and the coerceInputLiteral() method.
Example 1
import { GraphQLScalarType, Kind } from 'graphql'; const ensureOdd = (value) => { if (!Number.isFinite(value)) { throw new Error( `Scalar "Odd" cannot represent "${value}" since it is not a finite number.`, ); } if (value % 2 === 0) { throw new Error( `Scalar "Odd" cannot represent "${value}" since it is even.`, ); } return value; }; const OddType = new GraphQLScalarType({ name: 'Odd', coerceOutputValue: (value) => { return ensureOdd(value); }, coerceInputValue: (value) => { return ensureOdd(value); }, valueToLiteral: (value) => { return { kind: Kind.INT, value: String(ensureOdd(value)) }; }, });

constructor

constructor(config: Readonly<GraphQLScalarTypeConfig<TInternal, TExternal>>);

Creates a GraphQLScalarType instance.

Parameter config

Configuration describing this object.

Example 1

import { Kind, parse } from 'graphql/language';
import { GraphQLScalarType } from 'graphql/type';

const document = parse(`
  "Odd integer values."
  scalar Odd @specifiedBy(url: "https://example.com/odd")

  extend scalar Odd @specifiedBy(url: "https://example.com/odd-v2")
`);

const Odd = new GraphQLScalarType({
  name: 'Odd',
  description: 'Odd integer values.',
  specifiedByURL: 'https://example.com/odd',
  coerceOutputValue: (value) => {
    if (typeof value !== 'number' || value % 2 === 0) {
      throw new TypeError('Odd can only produce odd numbers.');
    }
    return value;
  },
  coerceInputValue: (value) => {
    if (typeof value !== 'number' || value % 2 === 0) {
      throw new TypeError('Odd can only accept odd numbers.');
    }
    return value;
  },
  coerceInputLiteral: (ast) => {
    if (ast.kind !== Kind.INT) {
      throw new TypeError('Odd can only accept integer literals.');
    }
    const value = Number(ast.value);
    if (value % 2 === 0) {
      throw new TypeError('Odd can only accept odd integer literals.');
    }
    return value;
  },
  valueToLiteral: (value) => {
    return { kind: Kind.INT, value: String(ensureOdd(value)) };
  },
  extensions: { numeric: true },
  astNode: document.definitions[0],
  extensionASTNodes: [document.definitions[1]],
});

Odd.description; // => 'Odd integer values.'
Odd.specifiedByURL; // => 'https://example.com/odd'
Odd.coerceOutputValue(3); // => 3
Odd.coerceInputValue(5); // => 5
Odd.extensions; // => { numeric: true }

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property astNode

astNode: ScalarTypeDefinitionNode;

AST node from which this schema element was built, if available.

property coerceInputLiteral

coerceInputLiteral: GraphQLScalarInputLiteralCoercer<TInternal>;

Coercer used to convert GraphQL scalar input literals.

property coerceInputValue

coerceInputValue: GraphQLScalarInputValueCoercer<TInternal>;

Coercer used to convert externally provided scalar input values.

property coerceOutputValue

coerceOutputValue: GraphQLScalarOutputValueCoercer<TExternal>;

Coercer used to convert internal scalar values for response output.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes: readonly ScalarTypeExtensionNode[];

AST extension nodes applied to this schema element.

property extensions

extensions: Readonly<GraphQLScalarTypeExtensions>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property parseLiteral

parseLiteral: GraphQLScalarLiteralParser<TInternal>;

Deprecated legacy parser used to convert externally provided input literals. Use replaceVariables() and coerceInputLiteral() instead.
Deprecated
use replaceVariables() and coerceInputLiteral() instead, parseLiteral() will be removed in v18

property parseValue

parseValue: GraphQLScalarValueParser<TInternal>;

Deprecated legacy parser used to convert externally provided input values. Use coerceInputValue() instead.
Deprecated
use coerceInputValue() instead, parseValue() will be removed in v18

property serialize

serialize: GraphQLScalarSerializer<TExternal>;

Deprecated legacy serializer used to convert internal values for response output. Use coerceOutputValue() instead.
Deprecated
use coerceOutputValue() instead, serialize() will be removed in v18

property specifiedByURL

specifiedByURL: string;

URL identifying the behavior specified for this custom scalar.

property valueToLiteral

valueToLiteral: GraphQLScalarValueToLiteral;

Converter used to produce GraphQL literals from runtime input values.

method toConfig

toConfig: () => GraphQLScalarTypeNormalizedConfig<TInternal, TExternal>;

Returns a normalized configuration object for this object.

Returns

A configuration object that can be used to recreate this object.

Example 1

import { GraphQLScalarType } from 'graphql/type';

const Url = new GraphQLScalarType({
  name: 'Url',
  description: 'An absolute URL string.',
  specifiedByURL: 'https://url.spec.whatwg.org/',
});

const config = Url.toConfig();
const UrlCopy = new GraphQLScalarType(config);

config.name; // => 'Url'
config.specifiedByURL; // => 'https://url.spec.whatwg.org/'
UrlCopy.name; // => Url.name

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import { GraphQLScalarType } from 'graphql/type';

const DateTime = new GraphQLScalarType({ name: 'DateTime' });

DateTime.toJSON(); // => 'DateTime'
JSON.stringify({ type: DateTime }); // => '{"type":"DateTime"}'

method toString

toString: () => string;

Returns the schema coordinate identifying this scalar type.

Returns

The schema coordinate for this scalar type.

Example 1

import { GraphQLScalarType } from 'graphql/type';

const DateTime = new GraphQLScalarType({ name: 'DateTime' });

DateTime.toString(); // => 'DateTime'
String(DateTime); // => 'DateTime'

class GraphQLSchema

class GraphQLSchema {}

Schema Definition

A Schema is created by supplying the root types of each type of operation, query and mutation (optional). A schema definition is then supplied to the validator and executor.

Example 1

const MyAppQueryRootType = new GraphQLObjectType({
  name: 'Query',
  fields: {
    greeting: { type: GraphQLString },
  },
});

const MyAppMutationRootType = new GraphQLObjectType({
  name: 'Mutation',
  fields: {
    setGreeting: { type: GraphQLString },
  },
});

const MyAppSchema = new GraphQLSchema({
  query: MyAppQueryRootType,
  mutation: MyAppMutationRootType,
});

Example 2

When the schema is constructed, by default only the types that are reachable by traversing the root types are included, other types must be explicitly referenced.

const characterInterface = new GraphQLInterfaceType({
  name: 'Character',
  fields: {
    name: { type: GraphQLString },
  },
});

const humanType = new GraphQLObjectType({
  name: 'Human',
  interfaces: [characterInterface],
  fields: {
    name: { type: GraphQLString },
  },
});

const droidType = new GraphQLObjectType({
  name: 'Droid',
  interfaces: [characterInterface],
  fields: {
    name: { type: GraphQLString },
  },
});

const schema = new GraphQLSchema({
  query: new GraphQLObjectType({
    name: 'Query',
    fields: {
      hero: { type: characterInterface },
    },
  }),
  // Since this schema references only the `Character` interface it's
  // necessary to explicitly list the types that implement it if
  // you want them to be included in the final schema.
  types: [humanType, droidType],
});

Example 3

If an array of directives are provided to GraphQLSchema, that will be the exact list of directives represented and allowed. If directives is not provided then a default set of the specified directives (e.g. @include and @skip) will be used. If you wish to provide *additional* directives to these specified directives, you must explicitly declare them.

const MyAppSchema = new GraphQLSchema({
  query: MyAppQueryRootType,
  directives: specifiedDirectives.concat([myCustomDirective]),
});

constructor

constructor(config: Readonly<GraphQLSchemaConfig>);

Creates a GraphQLSchema instance.

Parameter config

Configuration describing this object.

Example 1

// Create a schema with the required query root.
import { GraphQLObjectType, GraphQLSchema, GraphQLString } from 'graphql/type';

const Query = new GraphQLObjectType({
  name: 'Query',
  fields: {
    greeting: {
      type: GraphQLString,
      resolve: () => 'Hello',
    },
  },
});

const schema = new GraphQLSchema({
  description: 'The application schema.',
  query: Query,
});

schema.getQueryType(); // => Query
schema.description; // => 'The application schema.'

Example 2

// This variant configures every schema option, including directives and extensions.
import { DirectiveLocation, parse } from 'graphql/language';
import {
  GraphQLBoolean,
  GraphQLDirective,
  GraphQLObjectType,
  GraphQLSchema,
  GraphQLString,
} from 'graphql/type';

const Query = new GraphQLObjectType({
  name: 'Query',
  fields: { greeting: { type: GraphQLString } },
});
const Mutation = new GraphQLObjectType({
  name: 'Mutation',
  fields: { setGreeting: { type: GraphQLString } },
});
const Subscription = new GraphQLObjectType({
  name: 'Subscription',
  fields: { greetingChanged: { type: GraphQLString } },
});
const AuditEvent = new GraphQLObjectType({
  name: 'AuditEvent',
  fields: { message: { type: GraphQLString } },
});
const authDirective = new GraphQLDirective({
  name: 'auth',
  locations: [DirectiveLocation.FIELD_DEFINITION],
  args: { required: { type: GraphQLBoolean } },
});
const schemaDocument = parse(`
  schema {
    query: Query
    mutation: Mutation
    subscription: Subscription
  }

  extend schema @auth
`);

const schema = new GraphQLSchema({
  description: 'Operations exposed by the application.',
  query: Query,
  mutation: Mutation,
  subscription: Subscription,
  types: [AuditEvent],
  directives: [authDirective],
  extensions: { owner: 'platform' },
  astNode: schemaDocument.definitions[0],
  extensionASTNodes: [schemaDocument.definitions[1]],
  assumeValid: true,
});

schema.getMutationType(); // => Mutation
schema.getSubscriptionType(); // => Subscription
schema.getType('AuditEvent'); // => AuditEvent
schema.getDirective('auth'); // => authDirective
schema.extensions; // => { owner: 'platform' }

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property assumeValid

assumeValid: boolean;

Whether this schema instance skips validation checks.

property astNode

astNode: SchemaDefinitionNode;

AST node from which this schema element was built, if available.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes: readonly SchemaExtensionNode[];

AST extension nodes applied to this schema element.

property extensions

extensions: Readonly<GraphQLSchemaExtensions>;

Custom extension fields reserved for users.

method getDirective

getDirective: (name: string) => Maybe<GraphQLDirective>;

Returns the current directive definition.

Parameter name

The GraphQL name to look up.

Returns

The current directive definition, if known.

Example 1

import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(`
  directive @upper on FIELD_DEFINITION

  type Query {
    greeting: String @upper
  }
`);

schema.getDirective('upper')?.name; // => 'upper'
schema.getDirective('missing'); // => undefined

method getDirectives

getDirectives: () => ReadonlyArray<GraphQLDirective>;

Returns directives available in this schema.

Returns

Directives available in this schema.

Example 1

import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(`
  directive @upper on FIELD_DEFINITION

  type Query {
    greeting: String @upper
  }
`);

schema.getDirectives().map((directive) => directive.name); // => ['include', 'skip', 'deprecated', 'specifiedBy', 'oneOf', 'upper']

method getField

getField: (
    parentType: GraphQLCompositeType,
    fieldName: string
) => GraphQLField<unknown, unknown> | undefined;

This method looks up the field on the given type definition. It has special casing for the three introspection fields, __schema, __type and __typename.
__typename is special because it can always be queried as a field, even in situations where no other fields are allowed, like on a Union.
__schema and __type could get automatically added to the query type, but that would require mutating type definitions, which would cause issues.
Parameter parentType
Composite type to look up the field on.
Parameter fieldName
Field name to look up.
Returns
The field definition, including supported introspection fields.
Example 1
import { buildSchema } from 'graphql/utilities'; const schema = buildSchema(` type Query { greeting: String } `); const queryType = schema.getQueryType(); schema.getField(queryType, 'greeting')?.name; // => 'greeting' schema.getField(queryType, '__typename')?.name; // => '__typename' schema.getField(queryType, 'missing'); // => undefined

method getImplementations

getImplementations: (interfaceType: GraphQLInterfaceType) => {
    objects: ReadonlyArray<GraphQLObjectType>;
    interfaces: ReadonlyArray<GraphQLInterfaceType>;
};

Returns objects and interfaces that implement an interface type.

Parameter interfaceType

Interface type to inspect.

Returns

Object and interface implementations of the interface.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInterfaceType } from 'graphql/type';

const schema = buildSchema(`
  interface Resource {
    url: String!
  }

  interface Image implements Resource {
    url: String!
    width: Int
  }

  type Photo implements Resource & Image {
    url: String!
    width: Int
  }

  type Query {
    resource: Resource
  }
`);

const Resource = assertInterfaceType(schema.getType('Resource'));
const implementations = schema.getImplementations(Resource);

implementations.interfaces.map((type) => type.name); // => ['Image']
implementations.objects.map((type) => type.name); // => ['Photo']

method getMutationType

getMutationType: () => Maybe<GraphQLObjectType>;

Returns the root object type for mutation operations.

Returns

The mutation root type, if this schema defines one.

Example 1

import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }

  type Mutation {
    setGreeting(value: String!): String
  }
`);

schema.getMutationType()?.name; // => 'Mutation'

method getPossibleTypes

getPossibleTypes: (
    abstractType: GraphQLAbstractType
) => ReadonlyArray<GraphQLObjectType>;

Returns object types that may be returned for an abstract type.

Parameter abstractType

Interface or union type to inspect.

Returns

Object types that may satisfy the abstract type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInterfaceType, assertUnionType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Organization implements Node {
    id: ID!
  }

  union SearchResult = User | Organization

  type Query {
    node: Node
    search: [SearchResult]
  }
`);

const Node = assertInterfaceType(schema.getType('Node'));
const SearchResult = assertUnionType(schema.getType('SearchResult'));

schema.getPossibleTypes(Node).map((type) => type.name); // => ['User', 'Organization']
schema.getPossibleTypes(SearchResult).map((type) => type.name); // => ['User', 'Organization']

method getQueryType

getQueryType: () => Maybe<GraphQLObjectType>;

Returns the root object type for query operations.

Returns

The query root type, if this schema defines one.

Example 1

import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);

schema.getQueryType()?.name; // => 'Query'

method getRootType

getRootType: (operation: OperationTypeNode) => Maybe<GraphQLObjectType>;

Returns the root object type for the requested operation kind.

Parameter operation

Operation kind to resolve.

Returns

The root object type for the operation kind, if this schema defines one.

Example 1

import { OperationTypeNode } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }

  type Mutation {
    setGreeting(value: String!): String
  }
`);

schema.getRootType(OperationTypeNode.QUERY)?.name; // => 'Query'
schema.getRootType(OperationTypeNode.MUTATION)?.name; // => 'Mutation'
schema.getRootType(OperationTypeNode.SUBSCRIPTION); // => undefined

method getSubscriptionType

getSubscriptionType: () => Maybe<GraphQLObjectType>;

Returns the root object type for subscription operations.

Returns

The subscription root type, if this schema defines one.

Example 1

import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }

  type Subscription {
    greetings: String
  }
`);

schema.getSubscriptionType()?.name; // => 'Subscription'

method getType

getType: (name: string) => GraphQLNamedType | undefined;

Returns the named type with the provided name.

Parameter name

The GraphQL name to look up.

Returns

The named schema type, if one exists.

Example 1

import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type User {
    name: String
  }

  type Query {
    viewer: User
  }
`);

schema.getType('User')?.toString(); // => 'User'
schema.getType('Missing'); // => undefined

method getTypeMap

getTypeMap: () => TypeMap;

Returns all named types known to this schema.

Returns

A map of schema types keyed by type name.

Example 1

import { buildSchema } from 'graphql/utilities';

const schema = buildSchema(`
  type User {
    name: String
  }

  type Query {
    viewer: User
  }
`);

const typeMap = schema.getTypeMap();

typeMap.User.name; // => 'User'
typeMap.Query.name; // => 'Query'
typeMap.String.name; // => 'String'

method isSubType

isSubType: (
    abstractType: GraphQLAbstractType,
    maybeSubType: GraphQLObjectType | GraphQLInterfaceType
) => boolean;

Returns whether one type is a possible runtime subtype of an abstract type.

Parameter abstractType

Interface or union type to inspect.

Parameter maybeSubType

Object or interface type to test as a possible subtype.

Returns

True when the subtype may satisfy the abstract type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertInterfaceType, assertObjectType } from 'graphql/type';

const schema = buildSchema(`
  interface Node {
    id: ID!
  }

  type User implements Node {
    id: ID!
  }

  type Review {
    body: String
  }

  type Query {
    node: Node
    review: Review
  }
`);

const Node = assertInterfaceType(schema.getType('Node'));
const User = assertObjectType(schema.getType('User'));
const Review = assertObjectType(schema.getType('Review'));

schema.isSubType(Node, User); // => true
schema.isSubType(Node, Review); // => false

method toConfig

toConfig: () => GraphQLSchemaNormalizedConfig;

Returns a normalized configuration object for this object.

The returned config preserves the original assumeValid flag so the schema can be recreated with the same validation behavior.

Returns

A configuration object that can be used to recreate this object.

Example 1

import { buildSchema } from 'graphql/utilities';
import { GraphQLSchema } from 'graphql/type';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);

const config = schema.toConfig();
const schemaCopy = new GraphQLSchema(config);

config.query?.name; // => 'Query'
schemaCopy.getQueryType()?.name; // => 'Query'

class GraphQLUnionType

class GraphQLUnionType<TSource = any, TContext = any>
    implements GraphQLSchemaElement {}

Union Type Definition

When a field can return one of a heterogeneous set of types, a Union type is used to describe what types are possible as well as providing a function to determine which type is actually used when the field is resolved.

Example 1

const PetType = new GraphQLUnionType({
  name: 'Pet',
  types: [DogType, CatType],
  resolveType: (value) => {
    if (value instanceof Dog) {
      return DogType;
    }
    if (value instanceof Cat) {
      return CatType;
    }
  },
});

constructor

constructor(config: Readonly<GraphQLUnionTypeConfig<TSource, TContext>>);

Creates a GraphQLUnionType instance.

Parameter config

Configuration describing this object.

Example 1

import { parse } from 'graphql/language';
import {
  GraphQLObjectType,
  GraphQLString,
  GraphQLUnionType,
} from 'graphql/type';

const document = parse(`
  union Media = Photo | Video

  extend union Media = Audio
`);

const Photo = new GraphQLObjectType({
  name: 'Photo',
  fields: { url: { type: GraphQLString } },
});
const Video = new GraphQLObjectType({
  name: 'Video',
  fields: { url: { type: GraphQLString } },
});

const Media = new GraphQLUnionType({
  name: 'Media',
  description: 'Media that can appear in a search result.',
  types: [Photo, Video],
  resolveType: (value) => {
    return typeof value === 'object' && value != null && 'duration' in value
      ? 'Video'
      : 'Photo';
  },
  extensions: { searchable: true },
  astNode: document.definitions[0],
  extensionASTNodes: [document.definitions[1]],
});

Media.description; // => 'Media that can appear in a search result.'
Media.getTypes().map((type) => type.name); // => ['Photo', 'Video']
Media.extensions; // => { searchable: true }

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property astNode

astNode: UnionTypeDefinitionNode;

AST node from which this schema element was built, if available.

property description

description: string;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes: readonly UnionTypeExtensionNode[];

AST extension nodes applied to this schema element.

property extensions

extensions: Readonly<GraphQLUnionTypeExtensions>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property resolveType

resolveType: GraphQLTypeResolver<TSource, TContext>;

Function that resolves the concrete object type for this abstract type.

method getTypes

getTypes: () => ReadonlyArray<GraphQLObjectType>;

Returns the object types included in this union.

Returns

The union member object types.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertUnionType } from 'graphql/type';

const schema = buildSchema(`
  type Photo {
    url: String!
  }

  type Video {
    url: String!
  }

  union Media = Photo | Video

  type Query {
    media: [Media]
  }
`);

const Media = assertUnionType(schema.getType('Media'));

Media.getTypes().map((type) => type.name); // => ['Photo', 'Video']

method toConfig

toConfig: () => GraphQLUnionTypeNormalizedConfig<TSource, TContext>;

Returns a normalized configuration object for this object.

Returns

A configuration object that can be used to recreate this object.

Example 1

import {
  GraphQLObjectType,
  GraphQLString,
  GraphQLUnionType,
} from 'graphql/type';

const Photo = new GraphQLObjectType({
  name: 'Photo',
  fields: { url: { type: GraphQLString } },
});
const Video = new GraphQLObjectType({
  name: 'Video',
  fields: { url: { type: GraphQLString } },
});
const Media = new GraphQLUnionType({
  name: 'Media',
  types: [Photo, Video],
});

const config = Media.toConfig();
const MediaCopy = new GraphQLUnionType(config);

MediaCopy.getTypes().map((type) => type.name); // => ['Photo', 'Video']

method toJSON

toJSON: () => string;

Returns the JSON representation used when this object is serialized.

Returns

The JSON-serializable representation.

Example 1

import {
  GraphQLObjectType,
  GraphQLString,
  GraphQLUnionType,
} from 'graphql/type';

const Photo = new GraphQLObjectType({
  name: 'Photo',
  fields: { url: { type: GraphQLString } },
});
const SearchResult = new GraphQLUnionType({
  name: 'SearchResult',
  types: [Photo],
});

SearchResult.toJSON(); // => 'SearchResult'
JSON.stringify({ type: SearchResult }); // => '{"type":"SearchResult"}'

method toString

toString: () => string;

Returns the schema coordinate identifying this union type.

Returns

The schema coordinate for this union type.

Example 1

import { buildSchema } from 'graphql/utilities';
import { assertUnionType } from 'graphql/type';

const schema = buildSchema(`
  type Photo {
    url: String!
  }

  union SearchResult = Photo

  type Query {
    search: [SearchResult]
  }
`);

const SearchResult = assertUnionType(schema.getType('SearchResult'));

SearchResult.toString(); // => 'SearchResult'

class Lexer

class Lexer implements LexerInterface {}

Given a Source object, creates a Lexer for that source. A Lexer is a stateful stream generator in that every time it is advanced, it returns the next token in the Source. Assuming the source lexes, the final Token emitted by the lexer will be of kind EOF, after which the lexer will repeatedly return the same EOF token whenever called.

constructor

constructor(source: Source);

Creates a Lexer instance.

Parameter source

Source document used to derive error locations.

Example 1

import { Lexer, Source, TokenKind } from 'graphql/language';

const lexer = new Lexer(new Source('{ hello }'));

lexer.token.kind; // => TokenKind.SOF
lexer.advance().kind; // => TokenKind.BRACE_L
lexer.advance().value; // => 'hello'
lexer.advance().kind; // => TokenKind.BRACE_R

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property lastToken

lastToken: Token;

Most recent non-ignored token returned by the lexer.

property line

line: number;

The (1-indexed) line containing the current token.

property lineStart

lineStart: number;

Character offset where the current line starts.

property source

source: Source;

Source document used to derive error locations.

property token

token: Token;

Current non-ignored token at the lexer cursor.

method advance

advance: () => Token;

Advances the token stream to the next non-ignored token.

Returns

The next non-ignored token.

Example 1

import { Lexer, Source } from 'graphql/language';

const lexer = new Lexer(new Source('{ hello }'));
const token = lexer.advance();

token.kind; // => '{'
lexer.token; // => token

method lookahead

lookahead: () => Token;

Looks ahead and returns the next non-ignored token, but does not change the state of Lexer.

Returns

The next non-ignored token without advancing the lexer.

Example 1

import { Lexer, Source } from 'graphql/language';

const lexer = new Lexer(new Source('{ hello }'));
const token = lexer.lookahead();

token.kind; // => '{'
lexer.token.kind; // => '<SOF>'

class Location

class Location {}

Contains a range of UTF-8 character offsets and token references that identify the region of the source from which the AST derived.

constructor

constructor(startToken: Token, endToken: Token, source: Source);

Creates a Location instance.

Parameter startToken

The start token.

Parameter endToken

The end token.

Parameter source

Source document used to derive error locations.

Example 1

import { Location, Source, Token, TokenKind } from 'graphql/language';

const source = new Source('{ hello }');
const startToken = new Token(TokenKind.BRACE_L, 0, 1, 1, 1);
const endToken = new Token(TokenKind.BRACE_R, 8, 9, 1, 9);
const location = new Location(startToken, endToken, source);

location.start; // => 0
location.end; // => 9
location.source.body; // => '{ hello }'

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property end

readonly end: number;

The character offset at which this Node ends.

property endToken

readonly endToken: Token;

The Token at which this Node ends.

property source

readonly source: Source;

The Source document the AST represents.

property start

readonly start: number;

The character offset at which this Node begins.

property startToken

readonly startToken: Token;

The Token at which this Node begins.

method toJSON

toJSON: () => { start: number; end: number };

Returns a JSON representation of this location.

Returns

The JSON-serializable representation.

Example 1

import { parse } from 'graphql/language';

const document = parse('{ hello }');
const location = document.loc?.toJSON();

location; // => { start: 0, end: 9 }

class Source

class Source {}

A representation of source input to GraphQL. The name and locationOffset parameters are optional, but they are useful for clients who store GraphQL documents in source files. For example, if the GraphQL input starts at line 40 in a file named Foo.graphql, it might be useful for name to be "Foo.graphql" and location to be { line: 40, column: 1 }. The line and column properties in locationOffset are 1-indexed.

constructor

constructor(body: string, name?: string, locationOffset?: Location);

Creates a Source instance.

Parameter body

The GraphQL source text.

Parameter name

Name used in diagnostics for this source.

Parameter locationOffset

One-indexed line and column where this source begins.

Example 1

import { Source } from 'graphql/language';

const source = new Source('type Query { greeting: String }', 'schema.graphql', {
  line: 10,
  column: 1,
});

source.body; // => 'type Query { greeting: String }'
source.name; // => 'schema.graphql'
source.locationOffset; // => { line: 10, column: 1 }

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property body

body: string;

The GraphQL source text.

property locationOffset

locationOffset: Location;

One-indexed line and column where this source begins.

property name

name: string;

Name used in diagnostics for this source, such as a file path or request name.

class Token

class Token {}

Represents a range of characters represented by a lexical token within a Source.

constructor

constructor(
    kind: TokenKind,
    start: number,
    end: number,
    line: number,
    column: number,
    value?: string
);

Creates a Token instance.
Parameter kind
Token kind produced by lexical analysis.
Parameter start
Character offset where this token begins.
Parameter end
Character offset where this token ends.
Parameter line
One-indexed line number where this token begins.
Parameter column
One-indexed column number where this token begins.
Parameter value
Interpreted value for non-punctuation tokens.
Example 1
import { Token, TokenKind } from 'graphql/language'; const token = new Token(TokenKind.NAME, 2, 7, 1, 3, 'hello'); token.kind; // => TokenKind.NAME token.value; // => 'hello' token.toJSON(); // => { kind: 'Name', value: 'hello', line: 1, column: 3 }

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property column

readonly column: number;

The 1-indexed column number at which this Token begins.

property end

readonly end: number;

The character offset at which this Node ends.

property kind

readonly kind: TokenKind;

The kind of Token.

property line

readonly line: number;

The 1-indexed line number on which this Token appears.

property next

readonly next: Token;

Next token in the token stream, including ignored tokens.

property prev

readonly prev: Token;

Tokens exist as nodes in a double-linked-list amongst all tokens including ignored tokens. is always the first node and the last.

property start

readonly start: number;

The character offset at which this Node begins.

property value

readonly value: string;

For non-punctuation tokens, represents the interpreted value of the token.
Note: is undefined for punctuation tokens, but typed as string for convenience in the parser.

method toJSON

toJSON: () => { kind: TokenKind; value?: string; line: number; column: number };

Returns a JSON representation of this token.

Returns

The JSON-serializable representation.

Example 1

import { Lexer, Source } from 'graphql/language';

const lexer = new Lexer(new Source('{ hello }'));
const token = lexer.advance().toJSON();

token; // => { kind: '{', value: undefined, line: 1, column: 1 }

class TypeInfo

class TypeInfo {}

TypeInfo is a utility class which, given a GraphQL schema, can keep track of the current field and type definitions at any point in a GraphQL document AST during a recursive descent by calling enter(node) and leave(node).

constructor

constructor(
    schema: GraphQLSchema,
    initialType?: GraphQLType,
    fragmentSignatures?: (fragmentName: string) => Maybe<FragmentSignature>
);

Creates a TypeInfo instance.

Parameter schema

Schema used for type lookups.

Parameter initialType

Optional type to use at the start of traversal.

Parameter fragmentSignatures

Fragment signatures available during traversal.

Example 1

// Track field types during a visitWithTypeInfo traversal.
import { parse, visit } from 'graphql/language';
import { buildSchema } from 'graphql/utilities';
import { TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const typeInfo = new TypeInfo(schema);
const seenTypes = [];

visit(
  parse('{ greeting }'),
  visitWithTypeInfo(typeInfo, {
    Field: () => {
      seenTypes.push(String(typeInfo.getType()));
    },
  }),
);

seenTypes; // => ['String']

Example 2

// This variant starts from an initial type and supplies fragment signatures.
import { Kind, parse } from 'graphql/language';
import { buildSchema, TypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting(name: String): String
  }
`);
const fragmentDocument = parse(
  'fragment GreetingFields($name: String) on Query { greeting(name: $name) }',
  { experimentalFragmentArguments: true },
);
const fragmentDefinition = fragmentDocument.definitions[0];
const variableDefinition = fragmentDefinition.variableDefinitions[0];
const typeInfo = new TypeInfo(schema, schema.getQueryType(), (name) =>
  name === 'GreetingFields'
    ? {
        definition: fragmentDefinition,
        variableDefinitions: new Map([['name', variableDefinition]]),
      }
    : undefined,
);

typeInfo.enter({
  kind: Kind.SELECTION_SET,
  selections: [],
});
typeInfo.enter({
  kind: Kind.FRAGMENT_SPREAD,
  name: { kind: Kind.NAME, value: 'GreetingFields' },
  arguments: [],
  directives: [],
});

String(typeInfo.getParentType()); // => 'Query'
typeInfo.getFragmentSignature()?.definition.name.value; // => 'GreetingFields'

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

method enter

enter: (node: ASTNode) => void;

Updates this TypeInfo instance for an entered AST node.

Parameter node

AST node being entered.

Returns

Nothing.

Example 1

import { Kind, parse } from 'graphql/language';
import { buildSchema, TypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse('{ greeting }');
const operation = document.definitions[0];
const selectionSet = operation.selectionSet;
const field = selectionSet.selections[0];
const typeInfo = new TypeInfo(schema);

typeInfo.enter(operation);
typeInfo.enter(selectionSet);
typeInfo.enter(field);

field.kind; // => Kind.FIELD
typeInfo.getParentType()?.name; // => 'Query'
String(typeInfo.getType()); // => 'String'

method getArgument

getArgument: () => Maybe<GraphQLArgument>;

Returns the current argument definition.

Returns

The current argument definition, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    reviews(limit: Int = 10): [String]
  }
`);
const typeInfo = new TypeInfo(schema);
let argumentName;

visit(
  parse('{ reviews(limit: 5) }'),
  visitWithTypeInfo(typeInfo, {
    Argument: () => {
      argumentName = typeInfo.getArgument()?.name;
    },
  }),
);

argumentName; // => 'limit'

method getDefaultValue

getDefaultValue: () => unknown;

Returns the default input representation for the current input position.

Returns

The current default input, if one is available.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    reviews(limit: Int = 10): [String]
  }
`);
const typeInfo = new TypeInfo(schema);
let defaultLimit;

visit(
  parse('{ reviews(limit: 5) }'),
  visitWithTypeInfo(typeInfo, {
    Argument: () => {
      defaultLimit = typeInfo.getDefaultValue();
    },
  }),
);

defaultLimit; // => { literal: { kind: 'IntValue', value: '10' } }

method getDirective

getDirective: () => Maybe<GraphQLDirective>;

Returns the current directive definition.

Returns

The current directive definition, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const typeInfo = new TypeInfo(schema);
let directiveName;

visit(
  parse('{ greeting @include(if: true) }'),
  visitWithTypeInfo(typeInfo, {
    Directive: () => {
      directiveName = typeInfo.getDirective()?.name;
    },
  }),
);

directiveName; // => 'include'

method getEnumValue

getEnumValue: () => Maybe<GraphQLEnumValue>;

Returns the current enum value definition.

Returns

The current enum value definition, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  enum Sort {
    NEWEST
    OLDEST
  }

  type Query {
    reviews(sort: Sort = NEWEST): [String]
  }
`);
const typeInfo = new TypeInfo(schema);
let enumValueName;

visit(
  parse('{ reviews(sort: OLDEST) }'),
  visitWithTypeInfo(typeInfo, {
    EnumValue: () => {
      enumValueName = typeInfo.getEnumValue()?.name;
    },
  }),
);

enumValueName; // => 'OLDEST'

method getFieldDef

getFieldDef: () => Maybe<GraphQLField<unknown, unknown>>;

Returns the current field definition.

Returns

The current field definition, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const typeInfo = new TypeInfo(schema);
let fieldName;

visit(
  parse('{ greeting }'),
  visitWithTypeInfo(typeInfo, {
    Field: () => {
      fieldName = typeInfo.getFieldDef()?.name;
    },
  }),
);

fieldName; // => 'greeting'

method getFragmentArgument

getFragmentArgument: () => Maybe<VariableDefinitionNode>;

Returns the current fragment argument definition.

Returns

The variable definition for the current fragment argument.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting(name: String): String
  }
`);
const document = parse(
  `
    {
      ...GreetingFields(name: "Ada")
    }

    fragment GreetingFields($name: String) on Query {
      greeting(name: $name)
    }
  `,
  { experimentalFragmentArguments: true },
);
const typeInfo = new TypeInfo(schema);
let argumentName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    FragmentArgument: () => {
      argumentName = typeInfo.getFragmentArgument()?.variable.name.value;
    },
  }),
);

argumentName; // => 'name'

method getFragmentSignature

getFragmentSignature: () => Maybe<FragmentSignature>;

Returns the current fragment signature.

Returns

The fragment signature for the current fragment definition.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse(
  `
    {
      ...GreetingFields
    }

    fragment GreetingFields on Query {
      greeting
    }
  `,
  { experimentalFragmentArguments: true },
);
const typeInfo = new TypeInfo(schema);
let fragmentName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    FragmentSpread: () => {
      fragmentName = typeInfo.getFragmentSignature()?.definition.name.value;
    },
  }),
);

fragmentName; // => 'GreetingFields'

method getFragmentSignatureByName

getFragmentSignatureByName: () => (
    fragmentName: string
) => Maybe<FragmentSignature>;

Returns the function used to look up fragment signatures by name.

Returns

A function that maps fragment names to fragment signatures.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse(
  `
    {
      ...GreetingFields
    }

    fragment GreetingFields on Query {
      greeting
    }
  `,
  { experimentalFragmentArguments: true },
);
const typeInfo = new TypeInfo(schema);
let fragmentName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    Document: () => {
      const getFragmentSignature = typeInfo.getFragmentSignatureByName();
      fragmentName =
        getFragmentSignature('GreetingFields')?.definition.name.value;
    },
  }),
);

fragmentName; // => 'GreetingFields'

method getInputType

getInputType: () => Maybe<GraphQLInputType>;

Returns the current input type at this point in traversal.

Returns

The current input type, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    reviews(stars: Int!, sort: Sort = NEWEST): [String]
  }

  enum Sort {
    NEWEST
    OLDEST
  }
`);
const typeInfo = new TypeInfo(schema);
const inputTypes = {};

visit(
  parse('{ reviews(stars: 5, sort: OLDEST) }'),
  visitWithTypeInfo(typeInfo, {
    Argument: (node) => {
      inputTypes[node.name.value] = String(typeInfo.getInputType());
    },
  }),
);

inputTypes; // => { stars: 'Int!', sort: 'Sort' }

method getParentInputType

getParentInputType: () => Maybe<GraphQLInputType>;

Returns the parent input type for the current input position.

Returns

The parent input type, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  input ReviewFilter {
    stars: Int!
  }

  type Query {
    reviews(filter: ReviewFilter): [String]
  }
`);
const typeInfo = new TypeInfo(schema);
const parentInputTypes = {};

visit(
  parse('{ reviews(filter: { stars: 5 }) }'),
  visitWithTypeInfo(typeInfo, {
    ObjectField: (node) => {
      parentInputTypes[node.name.value] = String(typeInfo.getParentInputType());
    },
  }),
);

parentInputTypes; // => { stars: 'ReviewFilter' }

method getParentType

getParentType: () => Maybe<GraphQLCompositeType>;

Returns the current parent composite type.

Returns

The current parent composite type, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    viewer: User
  }

  type User {
    name: String
  }
`);
const typeInfo = new TypeInfo(schema);
const parentTypes = {};

visit(
  parse('{ viewer { name } }'),
  visitWithTypeInfo(typeInfo, {
    Field: (node) => {
      parentTypes[node.name.value] = String(typeInfo.getParentType());
    },
  }),
);

parentTypes; // => { viewer: 'Query', name: 'User' }

method getType

getType: () => Maybe<GraphQLOutputType>;

Returns the current output type at this point in traversal.

Returns

The current output type, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    viewer: User
  }

  type User {
    name: String
  }
`);
const typeInfo = new TypeInfo(schema);
const fieldTypes = {};

visit(
  parse('{ viewer { name } }'),
  visitWithTypeInfo(typeInfo, {
    Field: (node) => {
      fieldTypes[node.name.value] = String(typeInfo.getType());
    },
  }),
);

fieldTypes; // => { viewer: 'User', name: 'String' }

method leave

leave: (node: ASTNode) => void;

Updates this TypeInfo instance for a left AST node.

Parameter node

AST node being entered.

Returns

Nothing.

Example 1

import { parse } from 'graphql/language';
import { buildSchema, TypeInfo } from 'graphql/utilities';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse('{ greeting }');
const operation = document.definitions[0];
const selectionSet = operation.selectionSet;
const field = selectionSet.selections[0];
const typeInfo = new TypeInfo(schema);

typeInfo.enter(operation);
typeInfo.enter(selectionSet);
typeInfo.enter(field);
String(typeInfo.getType()); // => 'String'

typeInfo.leave(field);
typeInfo.getType(); // => undefined

class ValidationContext

class ValidationContext extends ASTValidationContext {}

Validation context passed to query validation rules.

constructor

constructor(
    schema: GraphQLSchema,
    ast: DocumentNode,
    typeInfo: TypeInfo,
    onError: (error: GraphQLError) => void,
    hideSuggestions?: boolean
);

Creates a ValidationContext instance.

Parameter schema

Schema used to validate the document.

Parameter ast

Document AST being validated.

Parameter typeInfo

TypeInfo instance used to track traversal state.

Parameter onError

Callback invoked for each validation error.

Parameter hideSuggestions

Whether suggestion text should be omitted from errors.

Example 1

import { parse } from 'graphql/language';
import { GraphQLError } from 'graphql/error';
import { buildSchema, TypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse('{ greeting }');
const errors = [];
const context = new ValidationContext(
  schema,
  document,
  new TypeInfo(schema),
  (error) => errors.push(error),
);

context.reportError(new GraphQLError('Example validation error.'));

context.getSchema(); // => schema
errors[0].message; // => 'Example validation error.'

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

Returns the value used by Object.prototype.toString.
Returns
The built-in string tag for this object.

property hideSuggestions

readonly hideSuggestions: boolean;

Returns whether validation error suggestions are hidden.
Returns
True when suggestion text should be omitted from errors.

method getArgument

getArgument: () => Maybe<GraphQLArgument>;

Returns the current argument definition.

Returns

The current argument definition, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    reviews(limit: Int): [String]
  }
`);
const document = parse('{ reviews(limit: 5) }');
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let argumentName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    Argument: () => {
      argumentName = context.getArgument()?.name;
    },
  }),
);

argumentName; // => 'limit'

method getDirective

getDirective: () => Maybe<GraphQLDirective>;

Returns the current directive definition.

Returns

The current directive definition, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse('{ greeting @include(if: true) }');
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let directiveName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    Directive: () => {
      directiveName = context.getDirective()?.name;
    },
  }),
);

directiveName; // => 'include'

method getEnumValue

getEnumValue: () => Maybe<GraphQLEnumValue>;

Returns the current enum value definition.

Returns

The current enum value definition, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  enum Sort {
    NEWEST
    OLDEST
  }

  type Query {
    reviews(sort: Sort): [String]
  }
`);
const document = parse('{ reviews(sort: OLDEST) }');
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let enumValueName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    EnumValue: () => {
      enumValueName = context.getEnumValue()?.name;
    },
  }),
);

enumValueName; // => 'OLDEST'

method getFieldDef

getFieldDef: () => Maybe<GraphQLField<unknown, unknown>>;

Returns the current field definition.

Returns

The current field definition, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse('{ greeting }');
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let fieldName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    Field: () => {
      fieldName = context.getFieldDef()?.name;
    },
  }),
);

fieldName; // => 'greeting'

method getFragmentSignature

getFragmentSignature: () => Maybe<FragmentSignature>;

Returns the fragment signature at the current traversal position.

Returns

The current fragment signature, if one is active.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse(
  `
    {
      ...GreetingFields
    }

    fragment GreetingFields on Query {
      greeting
    }
  `,
  { experimentalFragmentArguments: true },
);
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let fragmentName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    FragmentSpread: () => {
      fragmentName = context.getFragmentSignature()?.definition.name.value;
    },
  }),
);

fragmentName; // => 'GreetingFields'

method getFragmentSignatureByName

getFragmentSignatureByName: () => (
    fragmentName: string
) => Maybe<FragmentSignature>;

Returns the function used to look up fragment signatures by name.

Returns

A function that maps fragment names to fragment signatures.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse(
  `
    {
      ...GreetingFields
    }

    fragment GreetingFields on Query {
      greeting
    }
  `,
  { experimentalFragmentArguments: true },
);
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let fragmentName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    Document: () => {
      const getFragmentSignature = context.getFragmentSignatureByName();
      fragmentName =
        getFragmentSignature('GreetingFields')?.definition.name.value;
    },
  }),
);

fragmentName; // => 'GreetingFields'

method getInputType

getInputType: () => Maybe<GraphQLInputType>;

Returns the current input type at this point in traversal.

Returns

The current input type, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    reviews(limit: Int): [String]
  }
`);
const document = parse('{ reviews(limit: 5) }');
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let inputTypeName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    Argument: () => {
      inputTypeName = String(context.getInputType());
    },
  }),
);

inputTypeName; // => 'Int'

method getParentInputType

getParentInputType: () => Maybe<GraphQLInputType>;

Returns the parent input type for the current input position.

Returns

The parent input type, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  input ReviewFilter {
    stars: Int
  }

  type Query {
    reviews(filter: ReviewFilter): [String]
  }
`);
const document = parse('{ reviews(filter: { stars: 5 }) }');
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let parentInputTypeName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    ObjectField: () => {
      parentInputTypeName = String(context.getParentInputType());
    },
  }),
);

parentInputTypeName; // => 'ReviewFilter'

method getParentType

getParentType: () => Maybe<GraphQLCompositeType>;

Returns the current parent composite type.

Returns

The current parent composite type, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse('{ greeting }');
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let parentTypeName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    Field: () => {
      parentTypeName = context.getParentType()?.name;
    },
  }),
);

parentTypeName; // => 'Query'

method getRecursiveVariableUsages

getRecursiveVariableUsages: (
    operation: OperationDefinitionNode
) => ReadonlyArray<VariableUsage>;

Returns variable usages for an operation, including variables used by referenced fragments.

Parameter operation

Operation definition to inspect.

Returns

Variable usages reachable from the operation.

Example 1

import { parse } from 'graphql/language';
import { buildSchema, TypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    viewer: User
  }

  type User {
    name(prefix: String): String
  }
`);
const document = parse(`
  query ($prefix: String) {
    viewer {
      ...UserName
    }
  }

  fragment UserName on User {
    name(prefix: $prefix)
  }
`);
const operation = document.definitions[0];
const context = new ValidationContext(
  schema,
  document,
  new TypeInfo(schema),
  () => {},
);

const usages = context.getRecursiveVariableUsages(operation);

usages.map((usage) => usage.node.name.value); // => ['prefix']

method getSchema

getSchema: () => GraphQLSchema;

Returns the schema being used by this validation context.

Returns

The schema being validated against.

Example 1

import { parse } from 'graphql/language';
import { buildSchema, TypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const context = new ValidationContext(
  schema,
  parse('{ greeting }'),
  new TypeInfo(schema),
  () => {},
);

context.getSchema().getQueryType()?.name; // => 'Query'

method getType

getType: () => Maybe<GraphQLOutputType>;

Returns the current output type at this point in traversal.

Returns

The current output type, if known.

Example 1

import { parse, visit } from 'graphql/language';
import { buildSchema, TypeInfo, visitWithTypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
const document = parse('{ greeting }');
const typeInfo = new TypeInfo(schema);
const context = new ValidationContext(schema, document, typeInfo, () => {});
let typeName;

visit(
  document,
  visitWithTypeInfo(typeInfo, {
    Field: () => {
      typeName = String(context.getType());
    },
  }),
);

typeName; // => 'String'

method getVariableUsages

getVariableUsages: (node: NodeWithSelectionSet) => ReadonlyArray<VariableUsage>;

Returns variable usages found directly within this node.

Parameter node

The AST node to inspect or visit.

Returns

Variable usages found directly within this node.

Example 1

import { parse } from 'graphql/language';
import { buildSchema, TypeInfo } from 'graphql/utilities';
import { ValidationContext } from 'graphql/validation';

const schema = buildSchema(`
  type Query {
    greeting(name: String): String
  }
`);
const document = parse('query ($name: String) { greeting(name: $name) }');
const operation = document.definitions[0];
const context = new ValidationContext(
  schema,
  document,
  new TypeInfo(schema),
  () => {},
);

const usages = context.getVariableUsages(operation);

usages[0].node.name.value; // => 'name'
String(usages[0].type); // => 'String'

Interfaces

interface ArgumentCoordinateNode

interface ArgumentCoordinateNode {}

A schema coordinate that refers to a field or directive argument.

property argumentName

readonly argumentName: NameNode;

The argument name referenced by this schema coordinate.

property fieldName

readonly fieldName: NameNode;

The field name referenced by this schema coordinate.

property kind

readonly kind: KindTypeMap['ARGUMENT_COORDINATE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface ArgumentNode

interface ArgumentNode {}

An argument supplied to a field or directive.

property kind

readonly kind: KindTypeMap['ARGUMENT'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property value

readonly value: ValueNode;

Parsed value represented by this node.

interface AsyncWorkFinishedInfo

interface AsyncWorkFinishedInfo {}

Information passed to hooks after asynchronous execution work has finished.

property validatedExecutionArgs

validatedExecutionArgs: ValidatedExecutionArgs;

Validated execution arguments for the operation that finished async work.

interface BooleanValueNode

interface BooleanValueNode {}

A boolean value literal.

property kind

readonly kind: KindTypeMap['BOOLEAN'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property value

readonly value: boolean;

Parsed value represented by this node.

interface BreakingChange

interface BreakingChange {}

Description of a schema change that may break existing operations.

property description

description: string;

Human-readable description of the breaking schema change.

property type

type: BreakingChangeType;

Specific kind of breaking schema change.

interface BuildSchemaOptions

interface BuildSchemaOptions extends GraphQLSchemaValidationOptions {}

Options used when building a schema from SDL or a parsed SDL document.

property assumeValidSDL

assumeValidSDL?: boolean | undefined;

Set to true to assume the SDL is valid.
Default: false

interface ConstArgumentNode

interface ConstArgumentNode {}

An argument node whose value is guaranteed to be constant.

property kind

readonly kind: KindTypeMap['ARGUMENT'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property value

readonly value: ConstValueNode;

Parsed value represented by this node.

interface ConstDirectiveNode

interface ConstDirectiveNode {}

A directive whose arguments are all constant values.

property arguments

readonly arguments?: ReadonlyArray<ConstArgumentNode> | undefined;

Arguments supplied to this field, directive, or coordinate.

property kind

readonly kind: KindTypeMap['DIRECTIVE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface ConstListValueNode

interface ConstListValueNode {}

A list value literal whose elements are all constant values.

property kind

readonly kind: KindTypeMap['LIST'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property values

readonly values: ReadonlyArray<ConstValueNode>;

Values contained in this enum, list, or input-object definition.

interface ConstObjectFieldNode

interface ConstObjectFieldNode {}

A field inside a constant input object value literal.

property kind

readonly kind: KindTypeMap['OBJECT_FIELD'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property value

readonly value: ConstValueNode;

Parsed value represented by this node.

interface ConstObjectValueNode

interface ConstObjectValueNode {}

An input object value literal whose fields are all constant values.

property fields

readonly fields: ReadonlyArray<ConstObjectFieldNode>;

Fields declared by this object, interface, input object, or literal.

property kind

readonly kind: KindTypeMap['OBJECT'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

interface DangerousChange

interface DangerousChange {}

Description of a schema change that may be dangerous for existing operations.

property description

description: string;

Human-readable description of the dangerous schema change.

property type

type: DangerousChangeType;

Specific kind of dangerous schema change.

interface DirectiveArgumentCoordinateNode

interface DirectiveArgumentCoordinateNode {}

A schema coordinate that refers to a directive argument.

property argumentName

readonly argumentName: NameNode;

The argument name referenced by this schema coordinate.

property kind

readonly kind: KindTypeMap['DIRECTIVE_ARGUMENT_COORDINATE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface DirectiveCoordinateNode

interface DirectiveCoordinateNode {}

A schema coordinate that refers to a directive.

property kind

readonly kind: KindTypeMap['DIRECTIVE_COORDINATE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface DirectiveDefinitionNode

interface DirectiveDefinitionNode {}

A directive definition in a type-system document.

property arguments

readonly arguments?: ReadonlyArray<InputValueDefinitionNode> | undefined;

Arguments supplied to this field, directive, or coordinate.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['DIRECTIVE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property locations

readonly locations: ReadonlyArray<NameNode>;

Locations where this directive may be applied.

property name

readonly name: NameNode;

Name node identifying this AST node.

property repeatable

readonly repeatable: boolean;

Whether this directive may appear more than once at the same location.

interface DirectiveExtensionNode

interface DirectiveExtensionNode {}

A directive extension.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['DIRECTIVE_EXTENSION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface DirectiveNode

interface DirectiveNode {}

A directive applied to an executable or type-system location.

property arguments

readonly arguments?: ReadonlyArray<ArgumentNode> | undefined;

Arguments supplied to this field, directive, or coordinate.

property kind

readonly kind: KindTypeMap['DIRECTIVE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface DocumentNode

interface DocumentNode {}

The root AST node for a parsed GraphQL document.

property definitions

readonly definitions: ReadonlyArray<DefinitionNode>;

Top-level executable and type-system definitions in this document.

property kind

readonly kind: KindTypeMap['DOCUMENT'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property tokenCount

readonly tokenCount?: number | undefined;

The number of lexical tokens parsed for this document, if token counting was enabled.

interface EnumTypeDefinitionNode

interface EnumTypeDefinitionNode {}

An enum type definition in a type-system document.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['ENUM_TYPE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property values

readonly values?: ReadonlyArray<EnumValueDefinitionNode> | undefined;

Values contained in this enum, list, or input-object definition.

interface EnumTypeExtensionNode

interface EnumTypeExtensionNode {}

An enum type extension.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['ENUM_TYPE_EXTENSION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property values

readonly values?: ReadonlyArray<EnumValueDefinitionNode> | undefined;

Values contained in this enum, list, or input-object definition.

interface EnumValueDefinitionNode

interface EnumValueDefinitionNode {}

An enum value definition.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['ENUM_VALUE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface EnumValueNode

interface EnumValueNode {}

An enum value literal.

property kind

readonly kind: KindTypeMap['ENUM'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property value

readonly value: string;

Parsed value represented by this node.

interface ExecutionArgs

interface ExecutionArgs {}

Arguments accepted by execute and executeSync.

property abortSignal

abortSignal?: Maybe<AbortSignal>;

AbortSignal used to cancel execution.

property contextValue

contextValue?: unknown;

Application context value passed to every resolver.

property document

document: DocumentNode;

The parsed GraphQL document to execute.

property enableEarlyExecution

enableEarlyExecution?: Maybe<boolean>;

Whether incremental execution may begin eligible work early.

property fieldResolver

fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;

Resolver used when a field does not define its own resolver.

property hideSuggestions

hideSuggestions?: Maybe<boolean>;

Whether suggestion text should be omitted from request errors.

property hooks

hooks?: Maybe<ExecutionHooks>;

Execution hooks invoked during this operation.

property operationName

operationName?: Maybe<string>;

Name of the operation to execute when the document contains multiple operations.

property options

options?: {
    /**
     * Set the maximum number of errors allowed for coercing (defaults to 50).
     *
     * @internal
     */
    maxCoercionErrors?: number;
};

Additional execution options.

property rootValue

rootValue?: unknown;

Initial root value passed to the operation.

property schema

schema: GraphQLSchema;

The schema used for validation or execution.

property subscribeFieldResolver

subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;

Resolver used for the root subscription field.

property typeResolver

typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;

Resolver used when an abstract type does not define its own resolver.

property variableValues

variableValues?: Maybe<{
    readonly [variable: string]: unknown;
}>;

Runtime variable values keyed by variable name.

interface ExecutionHooks

interface ExecutionHooks {}

Optional hooks invoked during GraphQL execution.

property asyncWorkFinished

asyncWorkFinished?: (info: AsyncWorkFinishedInfo) => void;

Called after all tracked asynchronous execution work has settled.

interface ExecutionResult

interface ExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> {}

Represents the response produced by executing a GraphQL operation.

property data

data?: TData | null;

Data returned by execution, or null when execution could not produce data.

property errors

errors?: ReadonlyArray<GraphQLError>;

Errors raised while parsing, validating, or executing the operation.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in the execution result.

interface ExperimentalIncrementalExecutionResults

interface ExperimentalIncrementalExecutionResults<
    TInitialData = ObjMap<unknown>,
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

Results for an operation that produced incremental payloads.

property initialResult

initialResult: InitialIncrementalExecutionResult<TInitialData, TExtensions>;

Initial execution result delivered before subsequent incremental payloads.

property subsequentResults

subsequentResults: AsyncGenerator<
    SubsequentIncrementalExecutionResult<
        TDeferredData,
        TStreamItem,
        TExtensions
    >,
    void,
    void
>;

Async stream of incremental payloads delivered after the initial result.

interface FieldDefinitionNode

interface FieldDefinitionNode {}

A field definition declared by an object or interface type.

property arguments

readonly arguments?: ReadonlyArray<InputValueDefinitionNode> | undefined;

Arguments supplied to this field, directive, or coordinate.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['FIELD_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property type

readonly type: TypeNode;

The GraphQL type reference or runtime type for this element.

interface FieldNode

interface FieldNode {}

A field selected in an executable GraphQL document.

property alias

readonly alias?: NameNode | undefined;

The response-key alias for this field, if one was supplied.

property arguments

readonly arguments?: ReadonlyArray<ArgumentNode> | undefined;

Arguments supplied to this field, directive, or coordinate.

property directives

readonly directives?: ReadonlyArray<DirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['FIELD'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property selectionSet

readonly selectionSet?: SelectionSetNode | undefined;

Selections made by this operation, field, or fragment.

interface FloatValueNode

interface FloatValueNode {}

A floating-point value literal.

property kind

readonly kind: KindTypeMap['FLOAT'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property value

readonly value: string;

Parsed value represented by this node.

interface FormattedExecutionResult

interface FormattedExecutionResult<
    TData = ObjMap<unknown>,
    TExtensions = ObjMap<unknown>
> {}

A JSON-serializable GraphQL execution result.

property data

data?: TData | null;

Data returned by execution, or null when execution could not produce data.

property errors

errors?: ReadonlyArray<GraphQLFormattedError>;

Errors raised while parsing, validating, or executing the operation.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in the formatted result.

interface FormattedExperimentalIncrementalExecutionResults

interface FormattedExperimentalIncrementalExecutionResults<
    TInitial = ObjMap<unknown>,
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

JSON-serializable form of incremental execution results.

property initialResult

initialResult: FormattedInitialIncrementalExecutionResult<TInitial, TExtensions>;

Formatted initial execution result.

property subsequentResults

subsequentResults: AsyncGenerator<
    FormattedSubsequentIncrementalExecutionResult<
        TDeferredData,
        TStreamItem,
        TExtensions
    >,
    void,
    void
>;

Async stream of formatted incremental payloads.

interface FormattedIncrementalDeferResult

interface FormattedIncrementalDeferResult<
    TDeferredData = ObjMap<unknown>,
    TExtensions = ObjMap<unknown>
> {}

JSON-serializable form of a deferred fragment payload.

property data

data: TDeferredData;

Formatted data produced by the deferred fragment.

property errors

errors?: ReadonlyArray<GraphQLFormattedError>;

Formatted errors raised while executing the deferred fragment.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this formatted payload.

property id

id: string;

Identifier matching this payload to a pending deferred fragment.

property subPath

subPath?: ReadonlyArray<string | number>;

Path from the deferred fragment location to this payload.

interface FormattedIncrementalStreamResult

interface FormattedIncrementalStreamResult<
    TStreamItem = Array<unknown>,
    TExtensions = ObjMap<unknown>
> {}

JSON-serializable form of a streamed list payload.

property errors

errors?: ReadonlyArray<GraphQLFormattedError>;

Formatted errors raised while producing streamed items.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this formatted payload.

property id

id: string;

Identifier matching this payload to a pending stream.

property items

items: ReadonlyArray<TStreamItem>;

Formatted streamed list items delivered by this payload.

property subPath

subPath?: ReadonlyArray<string | number>;

Path from the streamed field location to these items.

interface FormattedInitialIncrementalExecutionResult

interface FormattedInitialIncrementalExecutionResult<
    TInitialData = ObjMap<unknown>,
    TExtensions = ObjMap<unknown>
> extends FormattedExecutionResult<TInitialData, TExtensions> {}

JSON-serializable form of an initial incremental execution result.

property data

data: TInitialData;

Formatted data produced by the initial execution payload.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in the formatted initial result.

property hasNext

hasNext: boolean;

Indicates whether subsequent incremental payloads will follow.

property pending

pending: ReadonlyArray<PendingResult>;

Formatted list of incremental payloads still pending after the initial result.

interface FormattedLegacyExperimentalIncrementalExecutionResults

interface FormattedLegacyExperimentalIncrementalExecutionResults<
    TInitialData = ObjMap<unknown>,
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

JSON-serializable form of legacy incremental execution results.

property initialResult

initialResult: FormattedLegacyInitialIncrementalExecutionResult<
    TInitialData,
    TExtensions
>;

Formatted initial execution result.

property subsequentResults

subsequentResults: AsyncGenerator<
    FormattedLegacySubsequentIncrementalExecutionResult<
        TDeferredData,
        TStreamItem,
        TExtensions
    >,
    void,
    void
>;

Async stream of formatted legacy incremental payloads.

interface FormattedLegacyIncrementalDeferResult

interface FormattedLegacyIncrementalDeferResult<
    TDeferredData = ObjMap<unknown>,
    TExtensions = ObjMap<unknown>
> extends FormattedExecutionResult<TDeferredData, TExtensions> {}

JSON-serializable form of a legacy deferred fragment payload.

property label

label?: string;

Label from the @defer directive.

property path

path: ReadonlyArray<string | number>;

Response path to the formatted deferred fragment payload.

interface FormattedLegacyIncrementalStreamResult

interface FormattedLegacyIncrementalStreamResult<
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

JSON-serializable form of a legacy streamed list payload.

property errors

errors?: ReadonlyArray<GraphQLFormattedError>;

Formatted errors raised while producing streamed items.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this formatted payload.

property items

items: ReadonlyArray<TStreamItem> | null;

Formatted streamed list items delivered by this payload.

property label

label?: string;

Label from the @stream directive.

property path

path: ReadonlyArray<string | number>;

Response path to the first streamed list item in this formatted payload.

interface FormattedLegacyInitialIncrementalExecutionResult

interface FormattedLegacyInitialIncrementalExecutionResult<
    TInitialData = ObjMap<unknown>,
    TExtensions = ObjMap<unknown>
> extends FormattedExecutionResult<TInitialData, TExtensions> {}

JSON-serializable form of a legacy initial incremental execution result.

property data

data: TInitialData;

Formatted data produced by the initial execution payload.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in the formatted initial result.

property hasNext

hasNext: true;

Indicates that subsequent legacy incremental payloads will follow.

interface FormattedLegacySubsequentIncrementalExecutionResult

interface FormattedLegacySubsequentIncrementalExecutionResult<
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

JSON-serializable form of a legacy subsequent incremental execution payload.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this formatted payload.

property hasNext

hasNext: boolean;

Indicates whether more legacy incremental payloads will follow.

property incremental

incremental?: ReadonlyArray<
    FormattedLegacyIncrementalResult<TDeferredData, TStreamItem, TExtensions>
>;

Formatted deferred or streamed payloads delivered by this response.

interface FormattedSubsequentIncrementalExecutionResult

interface FormattedSubsequentIncrementalExecutionResult<
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

JSON-serializable form of a subsequent incremental execution payload.

property completed

completed?: ReadonlyArray<FormattedCompletedResult>;

Formatted incremental payloads that completed with this response.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this formatted payload.

property hasNext

hasNext: boolean;

Indicates whether more incremental payloads will follow.

property incremental

incremental?: ReadonlyArray<
    FormattedIncrementalResult<TDeferredData, TStreamItem, TExtensions>
>;

Formatted deferred or streamed payloads delivered by this response.

property pending

pending?: ReadonlyArray<PendingResult>;

Formatted incremental payloads that became pending with this response.

interface FragmentArgumentNode

interface FragmentArgumentNode {}

Variable definition declared by a fragment argument.

property kind

readonly kind: KindTypeMap['FRAGMENT_ARGUMENT'];

AST node kind for a fragment argument.

property loc

readonly loc?: Location | undefined;

Source location for this fragment argument.

property name

readonly name: NameNode;

Variable name declared by this fragment argument.

property value

readonly value: ValueNode;

Default value literal for this fragment argument, if provided.

interface FragmentDefinitionNode

interface FragmentDefinitionNode {}

A reusable fragment definition declared in an executable document.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<DirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['FRAGMENT_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property selectionSet

readonly selectionSet: SelectionSetNode;

Selections made by this operation, field, or fragment.

property typeCondition

readonly typeCondition: NamedTypeNode;

The type condition that limits where this fragment applies.

property variableDefinitions

readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode> | undefined;

Experimental variable definitions declared by this fragment definition.

interface FragmentSpreadNode

interface FragmentSpreadNode {}

A named fragment spread, such as ...userFields.

property arguments

readonly arguments?: ReadonlyArray<FragmentArgumentNode> | undefined;

Argument values supplied to the referenced fragment.

property directives

readonly directives?: ReadonlyArray<DirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['FRAGMENT_SPREAD'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface GraphQLArgs

interface GraphQLArgs
    extends ParseOptions,
        ValidationOptions,
        Omit<ExecutionArgs, 'document'> {}

Describes the input object accepted by graphql and graphqlSync.
These arguments describe the full parse, validate, and execute lifecycle for a GraphQL request. They include parser options, validation options, execution options, and an optional harness for replacing pipeline stages.
graphql and graphqlSync do not support incremental delivery (@defer and @stream); use experimentalExecuteIncrementally after parsing and validating when incremental delivery is required.

property harness

harness?: GraphQLHarness | undefined;

Custom parse, validate, execute, and subscribe functions for this request pipeline.

property rules

rules?: ReadonlyArray<ValidationRule> | undefined;

Validation rules to use instead of the specified rules.

property source

source: string | Source;

A GraphQL language-formatted string or source object representing the requested operation.

interface GraphQLArgumentConfig

interface GraphQLArgumentConfig {}

Configuration used to define a GraphQL argument.

property astNode

astNode?: Maybe<InputValueDefinitionNode>;

AST node from which this schema element was built, if available.

property default

default?: GraphQLDefaultInput | undefined;

Default value represented as either a runtime value or a GraphQL literal.

property defaultValue

defaultValue?: unknown;

Deprecated legacy default value for this argument. Use default instead.
Deprecated
use default instead, defaultValue will be removed in v18

property deprecationReason

deprecationReason?: Maybe<string>;

Reason this element is deprecated, if one was provided.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensions

extensions?: Maybe<Readonly<GraphQLArgumentExtensions>>;

Custom extension fields reserved for users.

property type

type: GraphQLInputType;

The GraphQL type reference or runtime type for this element.

interface GraphQLArgumentExtensions

interface GraphQLArgumentExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLChannelContextByName

interface GraphQLChannelContextByName {}

Mapping from tracing channel name to the context type published on it.

property 'graphql:execute:rootSelectionSet'

'graphql:execute:rootSelectionSet': GraphQLExecuteRootSelectionSetContext;

Context published on graphql:execute:rootSelectionSet.

property 'graphql:execute:variableCoercion'

'graphql:execute:variableCoercion': GraphQLExecuteVariableCoercionContext;

Context published on graphql:execute:variableCoercion.

property 'graphql:execute'

'graphql:execute': GraphQLExecuteContext;

Context published on graphql:execute.

property 'graphql:parse'

'graphql:parse': GraphQLParseContext;

Context published on graphql:parse.

property 'graphql:resolve'

'graphql:resolve': GraphQLResolveContext;

Context published on graphql:resolve.

'graphql:subscribe': GraphQLSubscribeContext;

Context published on graphql:subscribe.

property 'graphql:validate'

'graphql:validate': GraphQLValidateContext;

Context published on graphql:validate.

interface GraphQLChannels

interface GraphQLChannels {}

The collection of tracing channels GraphQL.js emits on. Application performance monitoring (APM) tools subscribe to these by name on their own node:diagnostics_channel import; both paths land on the same channel instance because tracingChannel(name) is cached by name.

property execute

execute: MinimalTracingChannel<GraphQLExecuteContext>;

Tracing channel for graphql:execute.

property executeRootSelectionSet

executeRootSelectionSet: MinimalTracingChannel<GraphQLExecuteRootSelectionSetContext>;

Tracing channel for graphql:execute:rootSelectionSet.

property executeVariableCoercion

executeVariableCoercion: MinimalTracingChannel<GraphQLExecuteVariableCoercionContext>;

Tracing channel for graphql:execute:variableCoercion.

property parse

parse: MinimalTracingChannel<GraphQLParseContext>;

Tracing channel for graphql:parse.

property resolve

resolve: MinimalTracingChannel<GraphQLResolveContext>;

Tracing channel for graphql:resolve.

subscribe: MinimalTracingChannel<GraphQLSubscribeContext>;

Tracing channel for graphql:subscribe.

property validate

validate: MinimalTracingChannel<GraphQLValidateContext>;

Tracing channel for graphql:validate.

interface GraphQLDirectiveConfig

interface GraphQLDirectiveConfig {}

Configuration used to construct a GraphQLDirective.

property args

args?: Maybe<ObjMap<GraphQLArgumentConfig>>;

Arguments accepted by this field or directive.

property astNode

astNode?: Maybe<DirectiveDefinitionNode>;

AST node from which this schema element was built, if available.

property deprecationReason

deprecationReason?: Maybe<string>;

Reason this element is deprecated, if one was provided.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes?: Maybe<ReadonlyArray<DirectiveExtensionNode>>;

AST extension nodes applied to this schema element.

property extensions

extensions?: Maybe<Readonly<GraphQLDirectiveExtensions>>;

Custom extension fields reserved for users.

property isRepeatable

isRepeatable?: Maybe<boolean>;

Whether this directive may appear more than once at the same location.

property locations

locations: ReadonlyArray<DirectiveLocation>;

Locations where this directive may be applied.

property name

name: string;

The GraphQL name for this schema element.

interface GraphQLDirectiveExtensions

interface GraphQLDirectiveExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLEnumTypeConfig

interface GraphQLEnumTypeConfig {}

Configuration used to construct a GraphQLEnumType.

property astNode

astNode?: Maybe<EnumTypeDefinitionNode>;

AST node from which this schema element was built, if available.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes?: Maybe<ReadonlyArray<EnumTypeExtensionNode>>;

AST extension nodes applied to this schema element.

property extensions

extensions?: Maybe<Readonly<GraphQLEnumTypeExtensions>>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property values

values: ThunkObjMap<GraphQLEnumValueConfig>;

Values contained in this enum, list, or input-object definition.

interface GraphQLEnumTypeExtensions

interface GraphQLEnumTypeExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLEnumValueConfig

interface GraphQLEnumValueConfig {}

Configuration used to define a GraphQL enum value.

property astNode

astNode?: Maybe<EnumValueDefinitionNode>;

AST node from which this schema element was built, if available.

property deprecationReason

deprecationReason?: Maybe<string>;

Reason this element is deprecated, if one was provided.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensions

extensions?: Maybe<Readonly<GraphQLEnumValueExtensions>>;

Custom extension fields reserved for users.

property value

value?: any;

Parsed value represented by this node.

interface GraphQLEnumValueExtensions

interface GraphQLEnumValueExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLErrorExtensions

interface GraphQLErrorExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string]: unknown;

interface GraphQLErrorOptions

interface GraphQLErrorOptions {}

Options used to construct a GraphQLError.

property cause

cause?: unknown;

Cause of this GraphQLError, if one exists.

property extensions

extensions?: Maybe<GraphQLErrorExtensions>;

Extension fields to include in the formatted result.

property nodes

nodes?: ReadonlyArray<ASTNode> | ASTNode | null | undefined;

AST node or nodes associated with this error.

property originalError

originalError?: Maybe<
    Error & {
        readonly extensions?: unknown;
    }
>;

Original error that caused this GraphQLError, if one exists. Deprecated in favor of cause to better align with JavaScript standards.
Deprecated
Prefer cause instead.

property path

path?: Maybe<ReadonlyArray<string | number>>;

Response path where this error occurred during execution.

property positions

positions?: Maybe<ReadonlyArray<number>>;

Character offsets in the source document associated with this error.

property source

source?: Maybe<Source>;

Source document used to derive error locations.

interface GraphQLExecuteContext

interface GraphQLExecuteContext {}

Context published on graphql:execute.
Returned results may contain GraphQL errors collected during execution.

property document

document: DocumentNode;

Parsed document being executed.

property error

error?: unknown;

Error thrown or rejected while executing, when execution fails abruptly.

property operationName

operationName: string | undefined;

Selected operation name, if one is available.

property operationType

operationType: OperationTypeNode | undefined;

Selected operation type, if one is available.

property rawVariableValues

rawVariableValues: Maybe<{
    readonly [variable: string]: unknown;
}>;

Raw variable values provided by the caller before coercion.

property result

result?: ExecutionResult | ExperimentalIncrementalExecutionResults;

Execution result returned by execution, including GraphQL errors.

property schema

schema: GraphQLSchema;

Schema used for execution.

interface GraphQLExecuteRootSelectionSetContext

interface GraphQLExecuteRootSelectionSetContext {}

Context published on graphql:execute:rootSelectionSet.
Returned results may contain GraphQL errors collected during execution.

property document

document: DocumentNode;

Parsed document being executed.

property error

error?: unknown;

Error thrown or rejected while executing the root selection set.

property operation

operation: OperationDefinitionNode;

Operation definition selected for execution.

property operationName

operationName: string | undefined;

Selected operation name, if one is available.

property operationType

operationType: OperationTypeNode;

Selected operation type.

property rawVariableValues

rawVariableValues: Maybe<{
    readonly [variable: string]: unknown;
}>;

Raw variable values provided by the caller before coercion.

property result

result?: ExecutionResult | ExperimentalIncrementalExecutionResults;

Execution result returned from the root selection set, including GraphQL errors.

property schema

schema: GraphQLSchema;

Schema used for execution.

interface GraphQLExecuteVariableCoercionContext

interface GraphQLExecuteVariableCoercionContext {}

Context published on graphql:execute:variableCoercion.
Coercion runs synchronously while execution arguments are validated, so only the start/end (and, on an abrupt throw, error) lifecycle fires. Ordinary variable coercion failures are returned on result.errors; when execution is invoked through APIs such as execute() or subscribe(), they surface as GraphQL result errors rather than as the tracing error lifecycle event.

property document

document: DocumentNode;

Parsed document being executed.

property error

error?: unknown;

Error thrown while coercing variables, when coercion fails abruptly.

property operation

operation: OperationDefinitionNode;

Operation definition whose variables are being coerced.

property operationName

operationName: string | undefined;

Selected operation name, if one is available.

property operationType

operationType: OperationTypeNode;

Selected operation type.

property rawVariableValues

rawVariableValues: Maybe<{
    readonly [variable: string]: unknown;
}>;

Raw variable values provided by the caller before coercion.

property result

result?:
    | {
          variableValues: VariableValues;
      }
    | {
          errors: ReadonlyArray<GraphQLError>;
      };

Coerced variable values or coercion errors returned by coercion.

property schema

schema: GraphQLSchema;

Schema used for variable coercion.

interface GraphQLFieldConfig

interface GraphQLFieldConfig<TSource, TContext, TArgs = any> {}

Configuration used to define a GraphQL field.

property args

args?: GraphQLFieldConfigArgumentMap | undefined;

Arguments accepted by this field or directive.

property astNode

astNode?: Maybe<FieldDefinitionNode>;

AST node from which this schema element was built, if available.

property deprecationReason

deprecationReason?: Maybe<string>;

Reason this element is deprecated, if one was provided.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensions

extensions?: Maybe<Readonly<GraphQLFieldExtensions<TSource, TContext, TArgs>>>;

Custom extension fields reserved for users.

property resolve

resolve?: GraphQLFieldResolver<TSource, TContext, TArgs> | undefined;

Resolver function used to produce this field value.

subscribe?: GraphQLFieldResolver<TSource, TContext, TArgs> | undefined;

Resolver function used to create a subscription event stream for this field.

property type

type: GraphQLOutputType;

The GraphQL type reference or runtime type for this element.

interface GraphQLFieldExtensions

interface GraphQLFieldExtensions<_TSource, _TContext, _TArgs = any> {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need. We've provided these template arguments because this is an open type and you may find them useful.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLFormattedError

interface GraphQLFormattedError {}

See: https://spec.graphql.org/draft/#sec-Errors

property extensions

readonly extensions?: GraphQLFormattedErrorExtensions;

Reserved for implementors to extend the protocol however they see fit, and hence there are no additional restrictions on its contents.

property locations

readonly locations?: ReadonlyArray<SourceLocation>;

If an error can be associated to a particular point in the requested GraphQL document, it should contain a list of locations.

property message

readonly message: string;

A short, human-readable summary of the problem that **SHOULD NOT** change from occurrence to occurrence of the problem, except for purposes of localization.

property path

readonly path?: ReadonlyArray<string | number>;

If an error can be associated to a particular field in the GraphQL result, it _must_ contain an entry with the key path that details the path of the response field which experienced the error. This allows clients to identify whether a null result is intentional or caused by a runtime error.

interface GraphQLFormattedErrorExtensions

interface GraphQLFormattedErrorExtensions {}

Custom formatted extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string]: unknown;

interface GraphQLHarness

interface GraphQLHarness {}

Overrides for the parse, validate, execute, and subscribe stages used by the high-level graphql and graphqlSync request pipeline.

property execute

execute: GraphQLExecuteFn;

Executes a valid operation.

property parse

parse: GraphQLParseFn;

Parses GraphQL source text into a document AST.

subscribe: GraphQLSubscribeFn;

Creates a response stream for a subscription operation.

property validate

validate: GraphQLValidateFn;

Validates a document AST against a schema.

interface GraphQLInputFieldConfig

interface GraphQLInputFieldConfig {}

Configuration used to define a GraphQL input field.

property astNode

astNode?: Maybe<InputValueDefinitionNode>;

AST node from which this schema element was built, if available.

property default

default?: GraphQLDefaultInput | undefined;

Default value represented as either a runtime value or a GraphQL literal.

property defaultValue

defaultValue?: unknown;

Deprecated legacy default value for this input field. Use default instead.
Deprecated
use default instead, defaultValue will be removed in v18

property deprecationReason

deprecationReason?: Maybe<string>;

Reason this element is deprecated, if one was provided.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensions

extensions?: Maybe<Readonly<GraphQLInputFieldExtensions>>;

Custom extension fields reserved for users.

property type

type: GraphQLInputType;

The GraphQL type reference or runtime type for this element.

interface GraphQLInputFieldExtensions

interface GraphQLInputFieldExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLInputObjectTypeConfig

interface GraphQLInputObjectTypeConfig {}

Configuration used to construct a GraphQLInputObjectType.

property astNode

astNode?: Maybe<InputObjectTypeDefinitionNode>;

AST node from which this schema element was built, if available.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes?: Maybe<ReadonlyArray<InputObjectTypeExtensionNode>>;

AST extension nodes applied to this schema element.

property extensions

extensions?: Maybe<Readonly<GraphQLInputObjectTypeExtensions>>;

Custom extension fields reserved for users.

property fields

fields: ThunkObjMap<GraphQLInputFieldConfig>;

Fields declared by this object, interface, input object, or literal.

property isOneOf

isOneOf?: boolean;

Whether this input object uses the experimental OneOf input object semantics.

property name

name: string;

The GraphQL name for this schema element.

interface GraphQLInputObjectTypeExtensions

interface GraphQLInputObjectTypeExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLInterfaceTypeConfig

interface GraphQLInterfaceTypeConfig<TSource, TContext> {}

Configuration used to construct a GraphQLInterfaceType.

property astNode

astNode?: Maybe<InterfaceTypeDefinitionNode>;

AST node from which this schema element was built, if available.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes?: Maybe<ReadonlyArray<InterfaceTypeExtensionNode>>;

AST extension nodes applied to this schema element.

property extensions

extensions?: Maybe<Readonly<GraphQLInterfaceTypeExtensions>>;

Custom extension fields reserved for users.

property fields

fields: ThunkObjMap<GraphQLFieldConfig<TSource, TContext>>;

Fields declared by this object, interface, input object, or literal.

property interfaces

interfaces?: ThunkReadonlyArray<GraphQLInterfaceType> | undefined;

Interfaces implemented by this object or interface type.

property name

name: string;

The GraphQL name for this schema element.

property resolveType

resolveType?: Maybe<GraphQLTypeResolver<TSource, TContext>>;

Optionally provide a custom type resolver function. If one is not provided, the default implementation will call isTypeOf on each implementing Object type.

interface GraphQLInterfaceTypeExtensions

interface GraphQLInterfaceTypeExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLObjectTypeConfig

interface GraphQLObjectTypeConfig<TSource, TContext, TAbstract = unknown> {}

Configuration used to construct a GraphQLObjectType.

property astNode

astNode?: Maybe<ObjectTypeDefinitionNode>;

AST node from which this schema element was built, if available.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes?: Maybe<ReadonlyArray<ObjectTypeExtensionNode>>;

AST extension nodes applied to this schema element.

property extensions

extensions?: Maybe<Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>>;

Custom extension fields reserved for users.

property fields

fields: ThunkObjMap<GraphQLFieldConfig<TSource, TContext>>;

Fields declared by this object, interface, input object, or literal.

property interfaces

interfaces?: ThunkReadonlyArray<GraphQLInterfaceType> | undefined;

Interfaces implemented by this object or interface type.

property isTypeOf

isTypeOf?: Maybe<GraphQLIsTypeOfFn<TAbstract, TContext>>;

Predicate used to determine whether a runtime value belongs to this object type.

property name

name: string;

The GraphQL name for this schema element.

interface GraphQLObjectTypeExtensions

interface GraphQLObjectTypeExtensions<_TSource = any, _TContext = any> {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need. We've provided these template arguments because this is an open type and you may find them useful.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLParseContext

interface GraphQLParseContext {}

Context published on the sync-only graphql:parse channel.

property error

error?: unknown;

Error thrown while parsing, when parsing fails.

property result

result?: DocumentNode;

Parsed document, when parsing succeeds.

property source

source: string | Source;

Source text or source object passed to the parser.

interface GraphQLResolveContext

interface GraphQLResolveContext {}

Context published on graphql:resolve.
Resolver throws and rejections publish the error lifecycle event here. The same failure may also be formatted into the enclosing execution or subscription result.

property alias

alias: string;

Response alias for the field being resolved.

property args

args: ObjMap<unknown>;

Argument values passed to the resolver.

property error

error?: unknown;

Error thrown or rejected by the resolver, when resolution fails.

property fieldName

fieldName: string;

Field name being resolved.

property fieldPath

fieldPath: string;

Response path for the field being resolved.

property fieldType

fieldType: string;

Return type string for the field being resolved.

property isDefaultResolver

isDefaultResolver: boolean;

Whether the field is using the default resolver.

property parentType

parentType: string;

Parent type name for the field being resolved.

property result

result?: unknown;

Value returned by the resolver, when resolution succeeds.

interface GraphQLResolveInfo

interface GraphQLResolveInfo {}

Information about the currently executing GraphQL field.

property fieldName

readonly fieldName: string;

The field name referenced by this schema coordinate.

property fieldNodes

readonly fieldNodes: ReadonlyArray<FieldNode>;

AST field nodes that contributed to the current field execution.

property fragments

readonly fragments: ObjMap<FragmentDefinitionNode>;

Fragment definitions in the operation document keyed by fragment name.

property getAbortSignal

readonly getAbortSignal: () => AbortSignal | undefined;

Returns the AbortSignal supplied for this execution, if any.

property getAsyncHelpers

readonly getAsyncHelpers: () => GraphQLResolveInfoHelpers;

Returns helper functions for tracking asynchronous resolver work.

property operation

readonly operation: OperationDefinitionNode;

The operation selected for execution.

property parentType

readonly parentType: GraphQLObjectType;

Object type that owns the current field.

property path

readonly path: Path;

Response path where this error occurred during execution.

property returnType

readonly returnType: GraphQLOutputType;

GraphQL output type declared for the current field.

property rootValue

readonly rootValue: unknown;

Initial root value passed to the operation.

property schema

readonly schema: GraphQLSchema;

The schema used for validation or execution.

property variableValues

readonly variableValues: VariableValues;

Coerced variable values and source metadata for this operation. Resolver code that needs runtime variable values should read variableValues.coerced.

interface GraphQLResolveInfoHelpers

interface GraphQLResolveInfoHelpers {}

Utilities available from resolver info for tracking asynchronous work.

property promiseAll

readonly promiseAll: <T>(
    values: ReadonlyArray<PromiseLike<T> | T>
) => Promise<Array<T>>;

Promise.all wrapper that allows rejected branches to be tracked as execution async work.
Intended use: return or await this promise from resolver work. Un-awaited async side effects are an anti-pattern:
const { promiseAll } = info.getAsyncHelpers(); promiseAll([someAsyncWork(), someOtherAsyncWork()]).catch(() => undefined);
In that anti-pattern, tracking starts only after rejection (on a later microtask), so this work is not guaranteed to delay hooks.asyncWorkFinished.
Use track(...) for un-awaited async side effects:
const { track } = info.getAsyncHelpers(); track([ someAsyncWork().catch(() => undefined), someOtherAsyncWork().catch(() => undefined) ]);

property track

readonly track: (maybePromises: ReadonlyArray<unknown>) => void;

Tracks asynchronous work that should delay execution completion hooks.

interface GraphQLScalarTypeConfig

interface GraphQLScalarTypeConfig<TInternal, TExternal> {}

Configuration used to construct a GraphQLScalarType.

property astNode

astNode?: Maybe<ScalarTypeDefinitionNode>;

AST node from which this schema element was built, if available.

property coerceInputLiteral

coerceInputLiteral?: GraphQLScalarInputLiteralCoercer<TInternal> | undefined;

Coerces an externally provided const literal value to use as an input.

property coerceInputValue

coerceInputValue?: GraphQLScalarInputValueCoercer<TInternal> | undefined;

Coerces an externally provided value to use as an input.

property coerceOutputValue

coerceOutputValue?: GraphQLScalarOutputValueCoercer<TExternal> | undefined;

Coerces an internal value to include in a response.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes?: Maybe<ReadonlyArray<ScalarTypeExtensionNode>>;

AST extension nodes applied to this schema element.

property extensions

extensions?: Maybe<Readonly<GraphQLScalarTypeExtensions>>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property parseLiteral

parseLiteral?: GraphQLScalarLiteralParser<TInternal> | undefined;

Deprecated legacy parser used to convert externally provided input literals. Use replaceVariables() and coerceInputLiteral() instead.
Deprecated
use replaceVariables() and coerceInputLiteral() instead, parseLiteral() will be removed in v18

property parseValue

parseValue?: GraphQLScalarValueParser<TInternal> | undefined;

Deprecated legacy parser used to convert externally provided input values. Use coerceInputValue() instead.
Deprecated
use coerceInputValue() instead, parseValue() will be removed in v18

property serialize

serialize?: GraphQLScalarSerializer<TExternal> | undefined;

Deprecated legacy serializer used to convert internal values for response output. Use coerceOutputValue() instead.
Deprecated
use coerceOutputValue() instead, serialize() will be removed in v18

property specifiedByURL

specifiedByURL?: Maybe<string>;

URL identifying the behavior specified for this custom scalar.

property valueToLiteral

valueToLiteral?: GraphQLScalarValueToLiteral | undefined;

Translates an externally provided value to a literal (AST).

interface GraphQLScalarTypeExtensions

interface GraphQLScalarTypeExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLSchemaConfig

interface GraphQLSchemaConfig extends GraphQLSchemaValidationOptions {}

Configuration used to construct a GraphQLSchema.

property astNode

astNode?: Maybe<SchemaDefinitionNode>;

AST node from which this schema element was built, if available.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property directives

directives?: Maybe<ReadonlyArray<GraphQLDirective>>;

Directives available in this schema or applied to this AST node.

property extensionASTNodes

extensionASTNodes?: Maybe<ReadonlyArray<SchemaExtensionNode>>;

AST extension nodes applied to this schema element.

property extensions

extensions?: Maybe<Readonly<GraphQLSchemaExtensions>>;

Custom extension fields reserved for users.

property mutation

mutation?: Maybe<GraphQLObjectType>;

Root object type for mutation operations.

property query

query?: Maybe<GraphQLObjectType>;

Root object type for query operations.

property subscription

subscription?: Maybe<GraphQLObjectType>;

Root object type for subscription operations.

property types

types?: Maybe<ReadonlyArray<GraphQLNamedType>>;

Object types that belong to this union type.

interface GraphQLSchemaExtensions

interface GraphQLSchemaExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLSubscribeContext

interface GraphQLSubscribeContext {}

Context published on graphql:subscribe.
Subscription source resolver errors and invalid source stream results are returned on result as ExecutionResult errors; they do not publish the error lifecycle event unless subscription setup fails abruptly before GraphQL can form a result.

property document

document: DocumentNode;

Parsed subscription document.

property error

error?: unknown;

Error thrown or rejected while subscribing, when setup fails abruptly.

property operationName

operationName: string | undefined;

Selected operation name, if one is available.

property operationType

operationType: OperationTypeNode | undefined;

Selected operation type, if one is available.

property rawVariableValues

rawVariableValues: Maybe<{
    readonly [variable: string]: unknown;
}>;

Raw variable values provided by the caller before coercion.

property result

result?: AsyncGenerator<ExecutionResult, void, void> | ExecutionResult;

Subscription response stream, or an ExecutionResult containing GraphQL errors.

property schema

schema: GraphQLSchema;

Schema used for subscription execution.

interface GraphQLUnionTypeConfig

interface GraphQLUnionTypeConfig<TSource, TContext> {}

Configuration used to construct a GraphQLUnionType.

property astNode

astNode?: Maybe<UnionTypeDefinitionNode>;

AST node from which this schema element was built, if available.

property description

description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property extensionASTNodes

extensionASTNodes?: Maybe<ReadonlyArray<UnionTypeExtensionNode>>;

AST extension nodes applied to this schema element.

property extensions

extensions?: Maybe<Readonly<GraphQLUnionTypeExtensions>>;

Custom extension fields reserved for users.

property name

name: string;

The GraphQL name for this schema element.

property resolveType

resolveType?: Maybe<GraphQLTypeResolver<TSource, TContext>>;

Optionally provide a custom type resolver function. If one is not provided, the default implementation will call isTypeOf on each implementing Object type.

property types

types: ThunkReadonlyArray<GraphQLObjectType>;

Object types that belong to this union type.

interface GraphQLUnionTypeExtensions

interface GraphQLUnionTypeExtensions {}

Custom extensions
Remarks
Use a unique identifier name for your extension, for example the name of your library or project. Do not use a shortened identifier as this increases the risk of conflicts. We recommend you add at most one extension field, an object which can contain all the values you need.

index signature

[attributeName: string | symbol]: unknown;

interface GraphQLValidateContext

interface GraphQLValidateContext {}

Context published on the sync-only graphql:validate channel.

property document

document: DocumentNode;

Parsed document being validated.

property error

error?: unknown;

Error thrown while validating, when validation fails abruptly.

property result

result?: ReadonlyArray<GraphQLError>;

Validation errors returned by validation.

property schema

schema: GraphQLSchema;

Schema used for validation.

interface IncrementalDeferResult

interface IncrementalDeferResult<
    TDeferredData = ObjMap<unknown>,
    TExtensions = ObjMap<unknown>
> {}

Incremental payload produced by a deferred fragment.

property data

data: TDeferredData;

Data produced by the deferred fragment.

property errors

errors?: ReadonlyArray<GraphQLError>;

Errors raised while executing the deferred fragment.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this payload.

property id

id: string;

Identifier matching this payload to a pending deferred fragment.

property subPath

subPath?: ReadonlyArray<string | number>;

Path from the deferred fragment location to this payload.

interface IncrementalStreamResult

interface IncrementalStreamResult<
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

Incremental payload produced by a streamed list field.

property errors

errors?: ReadonlyArray<GraphQLError>;

Errors raised while producing streamed items.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this payload.

property id

id: string;

Identifier matching this payload to a pending stream.

property items

items: ReadonlyArray<TStreamItem>;

Streamed list items delivered by this payload.

property subPath

subPath?: ReadonlyArray<string | number>;

Path from the streamed field location to these items.

interface InitialIncrementalExecutionResult

interface InitialIncrementalExecutionResult<
    TData = ObjMap<unknown>,
    TExtensions = ObjMap<unknown>
> extends ExecutionResult<TData, TExtensions> {}

Initial execution result for an operation that produced incremental payloads.

property data

data: TData;

Data produced by the initial execution payload.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in the initial result.

property hasNext

hasNext: true;

Indicates that subsequent incremental payloads will follow.

property pending

pending: ReadonlyArray<PendingResult>;

Incremental payloads that are still pending after the initial result.

interface InlineFragmentNode

interface InlineFragmentNode {}

An inline fragment spread with an optional type condition.

property directives

readonly directives?: ReadonlyArray<DirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['INLINE_FRAGMENT'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property selectionSet

readonly selectionSet: SelectionSetNode;

Selections made by this operation, field, or fragment.

property typeCondition

readonly typeCondition?: NamedTypeNode | undefined;

The type condition that limits where this fragment applies.

interface InputObjectTypeDefinitionNode

interface InputObjectTypeDefinitionNode {}

An input object type definition in a type-system document.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property fields

readonly fields?: ReadonlyArray<InputValueDefinitionNode> | undefined;

Fields declared by this object, interface, input object, or literal.

property kind

readonly kind: KindTypeMap['INPUT_OBJECT_TYPE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface InputObjectTypeExtensionNode

interface InputObjectTypeExtensionNode {}

An input object type extension.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property fields

readonly fields?: ReadonlyArray<InputValueDefinitionNode> | undefined;

Fields declared by this object, interface, input object, or literal.

property kind

readonly kind: KindTypeMap['INPUT_OBJECT_TYPE_EXTENSION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface InputValueDefinitionNode

interface InputValueDefinitionNode {}

An argument or input-field definition.

property defaultValue

readonly defaultValue?: ConstValueNode | undefined;

Default value used when no explicit value is supplied.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['INPUT_VALUE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property type

readonly type: TypeNode;

The GraphQL type reference or runtime type for this element.

interface InterfaceTypeDefinitionNode

interface InterfaceTypeDefinitionNode {}

An interface type definition in a type-system document.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property fields

readonly fields?: ReadonlyArray<FieldDefinitionNode> | undefined;

Fields declared by this object, interface, input object, or literal.

property interfaces

readonly interfaces?: ReadonlyArray<NamedTypeNode> | undefined;

Interfaces implemented by this object or interface type.

property kind

readonly kind: KindTypeMap['INTERFACE_TYPE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface InterfaceTypeExtensionNode

interface InterfaceTypeExtensionNode {}

An interface type extension.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property fields

readonly fields?: ReadonlyArray<FieldDefinitionNode> | undefined;

Fields declared by this object, interface, input object, or literal.

property interfaces

readonly interfaces?: ReadonlyArray<NamedTypeNode> | undefined;

Interfaces implemented by this object or interface type.

property kind

readonly kind: KindTypeMap['INTERFACE_TYPE_EXTENSION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface IntrospectionDirective

interface IntrospectionDirective {}

The introspection representation of a directive.

property args

readonly args: ReadonlyArray<IntrospectionInputValue>;

Arguments accepted by this field or directive.

property deprecationReason

readonly deprecationReason?: Maybe<string>;

Reason this element is deprecated, if one was provided.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property isDeprecated

readonly isDeprecated?: boolean;

Whether this field, argument, enum value, or input value is deprecated.

property isRepeatable

readonly isRepeatable?: boolean;

Whether this directive may appear more than once at the same location.

property locations

readonly locations: ReadonlyArray<DirectiveLocation>;

Locations where this directive may be applied.

property name

readonly name: string;

The GraphQL name for this schema element.

interface IntrospectionEnumType

interface IntrospectionEnumType {}

The introspection representation of an enum type.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property enumValues

readonly enumValues: ReadonlyArray<IntrospectionEnumValue>;

Values declared by this enum type.

property kind

readonly kind: typeof TypeKind.ENUM;

The introspection kind discriminator for this type reference or type.

property name

readonly name: string;

The GraphQL name for this schema element.

interface IntrospectionEnumValue

interface IntrospectionEnumValue {}

The introspection representation of an enum value.

property deprecationReason

readonly deprecationReason: Maybe<string>;

Reason this element is deprecated, if one was provided.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property isDeprecated

readonly isDeprecated: boolean;

Whether this field, argument, enum value, or input value is deprecated.

property name

readonly name: string;

The GraphQL name for this schema element.

interface IntrospectionField

interface IntrospectionField {}

The introspection representation of a field.

property args

readonly args: ReadonlyArray<IntrospectionInputValue>;

Arguments accepted by this field or directive.

property deprecationReason

readonly deprecationReason: Maybe<string>;

Reason this element is deprecated, if one was provided.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property isDeprecated

readonly isDeprecated: boolean;

Whether this field, argument, enum value, or input value is deprecated.

property name

readonly name: string;

The GraphQL name for this schema element.

property type

readonly type: IntrospectionOutputTypeRef;

The GraphQL type reference or runtime type for this element.

interface IntrospectionInputObjectType

interface IntrospectionInputObjectType {}

The introspection representation of an input object type.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property inputFields

readonly inputFields: ReadonlyArray<IntrospectionInputValue>;

Input fields declared by this input object type.

property isOneOf

readonly isOneOf: boolean;

Whether this input object uses the experimental OneOf input object semantics.

property kind

readonly kind: typeof TypeKind.INPUT_OBJECT;

The introspection kind discriminator for this type reference or type.

property name

readonly name: string;

The GraphQL name for this schema element.

interface IntrospectionInputValue

interface IntrospectionInputValue {}

The introspection representation of an argument or input field.

property defaultValue

readonly defaultValue: Maybe<string>;

Default value used when no explicit value is supplied.

property deprecationReason

readonly deprecationReason?: Maybe<string>;

Reason this element is deprecated, if one was provided.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property isDeprecated

readonly isDeprecated?: boolean;

Whether this field, argument, enum value, or input value is deprecated.

property name

readonly name: string;

The GraphQL name for this schema element.

property type

readonly type: IntrospectionInputTypeRef;

The GraphQL type reference or runtime type for this element.

interface IntrospectionInterfaceType

interface IntrospectionInterfaceType {}

The introspection representation of an interface type.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property fields

readonly fields: ReadonlyArray<IntrospectionField>;

Fields declared by this object, interface, input object, or literal.

property interfaces

readonly interfaces: ReadonlyArray<
    IntrospectionNamedTypeRef<IntrospectionInterfaceType>
>;

Interfaces implemented by this object or interface type.

property kind

readonly kind: typeof TypeKind.INTERFACE;

The introspection kind discriminator for this type reference or type.

property name

readonly name: string;

The GraphQL name for this schema element.

property possibleTypes

readonly possibleTypes: ReadonlyArray<
    IntrospectionNamedTypeRef<IntrospectionObjectType>
>;

Object types that may be returned for this abstract type.

interface IntrospectionListTypeRef

interface IntrospectionListTypeRef<
    T extends IntrospectionTypeRef = IntrospectionTypeRef
> {}

The introspection representation of a list type reference.

property kind

readonly kind: typeof TypeKind.LIST;

The introspection kind discriminator for this type reference or type.

property ofType

readonly ofType: T;

The type wrapped by this list or non-null type.

interface IntrospectionNamedTypeRef

interface IntrospectionNamedTypeRef<
    T extends IntrospectionType = IntrospectionType
> {}

The introspection representation of a named type reference.

property kind

readonly kind: T['kind'];

The introspection kind discriminator for this type reference or type.

property name

readonly name: string;

The GraphQL name for this schema element.

interface IntrospectionNonNullTypeRef

interface IntrospectionNonNullTypeRef<
    T extends IntrospectionTypeRef = IntrospectionTypeRef
> {}

The introspection representation of a non-null type reference.

property kind

readonly kind: typeof TypeKind.NON_NULL;

The introspection kind discriminator for this type reference or type.

property ofType

readonly ofType: T;

The type wrapped by this list or non-null type.

interface IntrospectionObjectType

interface IntrospectionObjectType {}

The introspection representation of an object type.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property fields

readonly fields: ReadonlyArray<IntrospectionField>;

Fields declared by this object, interface, input object, or literal.

property interfaces

readonly interfaces: ReadonlyArray<
    IntrospectionNamedTypeRef<IntrospectionInterfaceType>
>;

Interfaces implemented by this object or interface type.

property kind

readonly kind: typeof TypeKind.OBJECT;

The introspection kind discriminator for this type reference or type.

property name

readonly name: string;

The GraphQL name for this schema element.

interface IntrospectionOptions

interface IntrospectionOptions {}

Options controlling which fields are included in the introspection query.

property descriptions

descriptions?: boolean;

Whether to include descriptions in the introspection result. Default: true

property directiveIsRepeatable

directiveIsRepeatable?: boolean;

Whether to include isRepeatable flag on directives. Default: false

property experimentalDirectiveDeprecation

experimentalDirectiveDeprecation?: boolean;

Whether target GraphQL server supports deprecation of directives. Default: false

property inputValueDeprecation

inputValueDeprecation?: boolean;

Whether target GraphQL server support deprecation of input values. Default: false

property oneOf

oneOf?: boolean;

Whether target GraphQL server supports @oneOf input objects. Default: false

property schemaDescription

schemaDescription?: boolean;

Whether to include description field on schema. Default: false

property specifiedByUrl

specifiedByUrl?: boolean;

Whether to include specifiedByURL in the introspection result. Default: false

property typeDepth

typeDepth?: number;

How deep to recurse into nested types, larger values will result in more accurate results, but have a higher load on the server. Some servers might restrict the maximum query depth or complexity. If that's the case, try decreasing this value.
Default: 9

interface IntrospectionQuery

interface IntrospectionQuery {}

The result shape returned by a full introspection query.

interface IntrospectionScalarType

interface IntrospectionScalarType {}

The introspection representation of a scalar type.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property kind

readonly kind: typeof TypeKind.SCALAR;

The introspection kind discriminator for this type reference or type.

property name

readonly name: string;

The GraphQL name for this schema element.

property specifiedByURL

readonly specifiedByURL?: Maybe<string>;

URL identifying the behavior specified for this custom scalar.

interface IntrospectionSchema

interface IntrospectionSchema {}

The introspection representation of a GraphQL schema.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property directives

readonly directives: ReadonlyArray<IntrospectionDirective>;

Directives available in this schema or applied to this AST node.

property mutationType

readonly mutationType: Maybe<IntrospectionNamedTypeRef<IntrospectionObjectType>>;

The root object type used for mutation operations, if supported.

property queryType

readonly queryType: IntrospectionNamedTypeRef<IntrospectionObjectType>;

The root object type used for query operations.

property subscriptionType

readonly subscriptionType: Maybe<
    IntrospectionNamedTypeRef<IntrospectionObjectType>
>;

The root object type used for subscription operations, if supported.

property types

readonly types: ReadonlyArray<IntrospectionType>;

Object types that belong to this union type.

interface IntrospectionUnionType

interface IntrospectionUnionType {}

The introspection representation of a union type.

property description

readonly description?: Maybe<string>;

Human-readable description for this schema element, if provided.

property kind

readonly kind: typeof TypeKind.UNION;

The introspection kind discriminator for this type reference or type.

property name

readonly name: string;

The GraphQL name for this schema element.

property possibleTypes

readonly possibleTypes: ReadonlyArray<
    IntrospectionNamedTypeRef<IntrospectionObjectType>
>;

Object types that may be returned for this abstract type.

interface IntValueNode

interface IntValueNode {}

An integer value literal.

property kind

readonly kind: KindTypeMap['INT'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property value

readonly value: string;

Parsed value represented by this node.

interface LegacyExperimentalIncrementalExecutionResults

interface LegacyExperimentalIncrementalExecutionResults<
    TInitialData = ObjMap<unknown>,
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

Results for an operation that produced legacy incremental payloads.

property initialResult

initialResult: LegacyInitialIncrementalExecutionResult<
    TInitialData,
    TExtensions
>;

Initial execution result delivered before subsequent legacy incremental payloads.

property subsequentResults

subsequentResults: AsyncGenerator<
    LegacySubsequentIncrementalExecutionResult<
        TDeferredData,
        TStreamItem,
        TExtensions
    >,
    void,
    void
>;

Async stream of legacy incremental payloads delivered after the initial result.

interface LegacyIncrementalDeferResult

interface LegacyIncrementalDeferResult<
    TDeferredData = ObjMap<unknown>,
    TExtensions = ObjMap<unknown>
> extends ExecutionResult<TDeferredData, TExtensions> {}

Legacy incremental payload produced by a deferred fragment.
The payload location is identified directly by path and optional label instead of by an id from a pending entry.

property label

label?: string;

Label from the @defer directive.

property path

path: ReadonlyArray<string | number>;

Response path to the deferred fragment payload.

interface LegacyIncrementalStreamResult

interface LegacyIncrementalStreamResult<
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

Legacy incremental payload produced by a streamed list field.

property errors

errors?: ReadonlyArray<GraphQLError>;

Errors raised while producing streamed items.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this payload.

property items

items: ReadonlyArray<TStreamItem> | null;

Streamed list items delivered by this payload.

property label

label?: string;

Label from the @stream directive.

property path

path: ReadonlyArray<string | number>;

Response path to the first streamed list item in this payload.

interface LegacyInitialIncrementalExecutionResult

interface LegacyInitialIncrementalExecutionResult<
    TInitialData = ObjMap<unknown>,
    TExtensions = ObjMap<unknown>
> extends ExecutionResult<TInitialData, TExtensions> {}

Initial execution result for an operation that produced legacy incremental payloads.
Unlike InitialIncrementalExecutionResult, the legacy initial result does not include a pending list. Subsequent payloads identify their location directly with path and optional label fields.

property data

data: TInitialData;

Data produced by the initial execution payload.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in the initial result.

property hasNext

hasNext: true;

Indicates that subsequent legacy incremental payloads will follow.

interface LegacySubsequentIncrementalExecutionResult

interface LegacySubsequentIncrementalExecutionResult<
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

Subsequent payload produced by legacy incremental execution.
Legacy subsequent payloads may contain deferred fragment data, streamed list items, or only hasNext: false to complete the response stream.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this payload.

property hasNext

hasNext: boolean;

Indicates whether more legacy incremental payloads will follow.

property incremental

incremental?: ReadonlyArray<
    LegacyIncrementalResult<TDeferredData, TStreamItem, TExtensions>
>;

Deferred or streamed payloads delivered by this response.

interface ListTypeNode

interface ListTypeNode {}

A list type reference.

property kind

readonly kind: KindTypeMap['LIST_TYPE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property type

readonly type: TypeNode;

The GraphQL type reference or runtime type for this element.

interface ListValueNode

interface ListValueNode {}

A list value literal.

property kind

readonly kind: KindTypeMap['LIST'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property values

readonly values: ReadonlyArray<ValueNode>;

Values contained in this enum, list, or input-object definition.

interface MemberCoordinateNode

interface MemberCoordinateNode {}

A schema coordinate that refers to a member of a named type.

property kind

readonly kind: KindTypeMap['MEMBER_COORDINATE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location;

The source location for this AST node, if location tracking was enabled.

property memberName

readonly memberName: NameNode;

The member name referenced by this schema coordinate.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface NamedTypeNode

interface NamedTypeNode {}

A named type reference.

property kind

readonly kind: KindTypeMap['NAMED_TYPE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface NameNode

interface NameNode {}

An identifier in a GraphQL document.

property kind

readonly kind: KindTypeMap['NAME'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property value

readonly value: string;

Parsed value represented by this node.

interface NonNullTypeNode

interface NonNullTypeNode {}

A non-null type reference.

property kind

readonly kind: KindTypeMap['NON_NULL_TYPE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property type

readonly type: NamedTypeNode | ListTypeNode;

The GraphQL type reference or runtime type for this element.

interface NullValueNode

interface NullValueNode {}

A null value literal.

property kind

readonly kind: KindTypeMap['NULL'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

interface ObjectFieldNode

interface ObjectFieldNode {}

A field inside an input object value literal.

property kind

readonly kind: KindTypeMap['OBJECT_FIELD'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property value

readonly value: ValueNode;

Parsed value represented by this node.

interface ObjectTypeDefinitionNode

interface ObjectTypeDefinitionNode {}

An object type definition in a type-system document.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property fields

readonly fields?: ReadonlyArray<FieldDefinitionNode> | undefined;

Fields declared by this object, interface, input object, or literal.

property interfaces

readonly interfaces?: ReadonlyArray<NamedTypeNode> | undefined;

Interfaces implemented by this object or interface type.

property kind

readonly kind: KindTypeMap['OBJECT_TYPE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface ObjectTypeExtensionNode

interface ObjectTypeExtensionNode {}

An object type extension.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property fields

readonly fields?: ReadonlyArray<FieldDefinitionNode> | undefined;

Fields declared by this object, interface, input object, or literal.

property interfaces

readonly interfaces?: ReadonlyArray<NamedTypeNode> | undefined;

Interfaces implemented by this object or interface type.

property kind

readonly kind: KindTypeMap['OBJECT_TYPE_EXTENSION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface ObjectValueNode

interface ObjectValueNode {}

An input object value literal.

property fields

readonly fields: ReadonlyArray<ObjectFieldNode>;

Fields declared by this object, interface, input object, or literal.

property kind

readonly kind: KindTypeMap['OBJECT'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

interface OperationDefinitionNode

interface OperationDefinitionNode {}

A query, mutation, or subscription operation definition.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<DirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['OPERATION_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name?: NameNode | undefined;

Name node identifying this AST node.

property operation

readonly operation: OperationTypeNode;

The operation selected for execution.

property selectionSet

readonly selectionSet: SelectionSetNode;

Selections made by this operation, field, or fragment.

property variableDefinitions

readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode> | undefined;

Variable definitions declared by this operation or fragment.

interface OperationTypeDefinitionNode

interface OperationTypeDefinitionNode {}

A root operation type declaration inside a schema definition or extension.

property kind

readonly kind: KindTypeMap['OPERATION_TYPE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property operation

readonly operation: OperationTypeNode;

The operation selected for execution.

property type

readonly type: NamedTypeNode;

The GraphQL type reference or runtime type for this element.

interface ParseOptions

interface ParseOptions {}

Configuration options to control parser behavior

property experimentalFragmentArguments

experimentalFragmentArguments?: boolean | undefined;

EXPERIMENTAL:
If enabled, the parser will understand and parse fragment variable definitions and arguments on fragment spreads. Fragment variable definitions will be represented in the variableDefinitions field of the FragmentDefinitionNode. Fragment spread arguments will be represented in the arguments field of FragmentSpreadNode.
Example 1
{ t { ...A(var: true) } } fragment A($var: Boolean = false) on T { ...B(x: $var) }

property maxTokens

maxTokens?: number | undefined;

Parser CPU and memory usage is linear to the number of tokens in a document however in extreme cases it becomes quadratic due to memory exhaustion. Parsing happens before validation so even invalid queries can burn lots of CPU time and memory. To prevent this you can set a maximum number of tokens allowed within a document.

property noLocation

noLocation?: boolean | undefined;

By default, the parser creates AST nodes that know the location in the source that they correspond to. This configuration flag disables that behavior for performance or testing.

interface ResponsePath

interface Path {}

Represents a linked response path from a field back to the root response.

property key

readonly key: string | number;

The field name or list index for this response path segment.

property prev

readonly prev: Path | undefined;

The previous segment in the linked response path, or undefined at the root.

property typename

readonly typename: string | undefined;

The runtime object type name associated with this path segment, if known.

interface SafeChange

interface SafeChange {}

Description of a schema change that is considered safe for existing operations.

property description

description: string;

Human-readable description of the safe schema change.

property type

type: SafeChangeType;

Specific kind of safe schema change.

interface ScalarTypeDefinitionNode

interface ScalarTypeDefinitionNode {}

A scalar type definition in a type-system document.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['SCALAR_TYPE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface ScalarTypeExtensionNode

interface ScalarTypeExtensionNode {}

A scalar type extension.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['SCALAR_TYPE_EXTENSION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface SchemaDefinitionNode

interface SchemaDefinitionNode {}

A schema definition in a type-system document.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['SCHEMA_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property operationTypes

readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;

Root operation types declared by this schema definition or extension.

interface SchemaExtensionNode

interface SchemaExtensionNode {}

A schema extension in a type-system document.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['SCHEMA_EXTENSION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property operationTypes

readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode> | undefined;

Root operation types declared by this schema definition or extension.

interface SelectionSetNode

interface SelectionSetNode {}

A set of fields and fragments selected from an object, interface, or union.

property kind

kind: KindTypeMap['SELECTION_SET'];

The discriminator identifying the concrete AST or introspection kind.

property loc

loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property selections

selections: ReadonlyArray<SelectionNode>;

Fields and fragments contained in this selection set.

interface SourceLocation

interface SourceLocation {}

Represents a location in a Source.

property column

readonly column: number;

One-indexed column number in the source document.

property line

readonly line: number;

One-indexed line number in the source document.

interface StringValueNode

interface StringValueNode {}

A string value literal.

property block

readonly block?: boolean | undefined;

Whether this string was parsed from block string syntax.

property kind

readonly kind: KindTypeMap['STRING'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property value

readonly value: string;

Parsed value represented by this node.

interface SubscriptionOperationDefinitionNode

interface SubscriptionOperationDefinitionNode extends OperationDefinitionNode {}

A narrowed OperationDefinitionNode for subscription operations. Subscription operations go through a distinct execution pipeline (source event stream + per-event execution), so narrowing the operation type allows functions in that pipeline to accept only valid input.

property operation

readonly operation: (typeof OperationTypeNode)['SUBSCRIPTION'];

Subscription operation kind for this definition.

interface SubsequentIncrementalExecutionResult

interface SubsequentIncrementalExecutionResult<
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> {}

Subsequent payload produced by incremental execution.

property completed

completed?: ReadonlyArray<CompletedResult>;

Incremental payloads that completed with this response.

property extensions

extensions?: TExtensions;

Additional non-standard metadata included in this payload.

property hasNext

hasNext: boolean;

Indicates whether more incremental payloads will follow.

property incremental

incremental?: ReadonlyArray<
    IncrementalResult<TDeferredData, TStreamItem, TExtensions>
>;

Deferred or streamed payloads delivered by this response.

property pending

pending?: ReadonlyArray<PendingResult>;

Incremental payloads that became pending with this response.

interface TypeCoordinateNode

interface TypeCoordinateNode {}

A schema coordinate that refers to a named type.

property kind

readonly kind: KindTypeMap['TYPE_COORDINATE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface TypedQueryDocumentNode

interface TypedQueryDocumentNode<
    TResponseData = {
        [key: string]: any;
    },
    TRequestVariables = {
        [key: string]: any;
    }
> extends DocumentNode {}

Wrapper type that contains DocumentNode and types that can be deduced from it.

property definitions

readonly definitions: ReadonlyArray<ExecutableDefinitionNode>;

Top-level executable and type-system definitions in this document.

interface UnionTypeDefinitionNode

interface UnionTypeDefinitionNode {}

A union type definition in a type-system document.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['UNION_TYPE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property types

readonly types?: ReadonlyArray<NamedTypeNode> | undefined;

Object types that belong to this union type.

interface UnionTypeExtensionNode

interface UnionTypeExtensionNode {}

A union type extension.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['UNION_TYPE_EXTENSION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

property types

readonly types?: ReadonlyArray<NamedTypeNode> | undefined;

Object types that belong to this union type.

interface ValidatedExecutionArgs

interface ValidatedExecutionArgs {}

Data that must be available at all points during query execution.
Namely, schema of the type system that is currently executing, and the fragments defined in the query document

property contextValue

contextValue: unknown;

Application context value passed to every resolver.

property document

document: DocumentNode;

Parsed GraphQL document being executed.

property enableEarlyExecution

enableEarlyExecution: boolean;

Whether incremental execution may begin eligible work early.

property errorPropagation

errorPropagation: boolean;

Whether execution should use error propagation.

property externalAbortSignal

externalAbortSignal: AbortSignal | undefined;

External signal that may abort execution.

property fieldResolver

fieldResolver: GraphQLFieldResolver<any, any>;

Resolver used for fields without an explicit resolver.

property fragmentDefinitions

fragmentDefinitions: ObjMap<FragmentDefinitionNode>;

Fragment definitions keyed by fragment name.

property fragments

fragments: ObjMap<FragmentDetails>;

Fragment details keyed by fragment name.

property hideSuggestions

hideSuggestions: boolean;

Whether suggestion text should be omitted from execution errors.

property hooks

hooks: ExecutionHooks | undefined;

Execution hooks supplied by the caller.

property operation

operation: OperationDefinitionNode;

Operation definition selected for execution.

property rawVariableValues

rawVariableValues: Maybe<{
    readonly [variable: string]: unknown;
}>;

Raw variable values provided by the caller before coercion.

property rootValue

rootValue: unknown;

Root value passed to the operation.

property schema

schema: GraphQLSchema;

Schema used for execution.

property subscribeFieldResolver

subscribeFieldResolver: GraphQLFieldResolver<any, any>;

Resolver used for subscription fields without an explicit subscribe resolver.

property typeResolver

typeResolver: GraphQLTypeResolver<any, any>;

Resolver used for abstract types without an explicit type resolver.

property variableValues

variableValues: VariableValues;

Operation variable values with source metadata and coerced runtime values.

interface ValidatedSubscriptionArgs

interface ValidatedSubscriptionArgs extends ValidatedExecutionArgs {}

Validated execution arguments for a subscription operation.

property operation

operation: SubscriptionOperationDefinitionNode;

Subscription operation definition selected for execution.

interface ValidationOptions

interface ValidationOptions {}

Options used when validating a GraphQL document. Validation

property hideSuggestions

hideSuggestions?: Maybe<boolean>;

Whether suggestion text should be omitted from validation errors.

property maxErrors

maxErrors?: number;

Maximum number of validation errors before validation stops.

interface VariableDefinitionNode

interface VariableDefinitionNode {}

A variable declaration in an operation or experimental fragment definition.

property defaultValue

readonly defaultValue?: ConstValueNode | undefined;

Default value used when no explicit value is supplied.

property description

readonly description?: StringValueNode | undefined;

The optional GraphQL description associated with this definition.

property directives

readonly directives?: ReadonlyArray<ConstDirectiveNode> | undefined;

Directives available in this schema or applied to this AST node.

property kind

readonly kind: KindTypeMap['VARIABLE_DEFINITION'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property type

readonly type: TypeNode;

The GraphQL type reference or runtime type for this element.

property variable

readonly variable: VariableNode;

The variable being defined or referenced.

interface VariableNode

interface VariableNode {}

A variable reference, such as $id.

property kind

readonly kind: KindTypeMap['VARIABLE'];

The discriminator identifying the concrete AST or introspection kind.

property loc

readonly loc?: Location | undefined;

The source location for this AST node, if location tracking was enabled.

property name

readonly name: NameNode;

Name node identifying this AST node.

interface VariableValues

interface VariableValues {}

Coerced variable values prepared for execution.
The coerced map contains runtime values keyed by variable name. The sources map records whether each value came from request input, an operation default, or a fragment-variable default so utilities can preserve defaults when replacing variables in literals.

property coerced

readonly coerced: ReadOnlyObjMap<unknown>;

Coerced runtime variable values keyed by variable name.

property sources

readonly sources: ReadOnlyObjMap<VariableValueSource>;

Source metadata for each variable value keyed by variable name.

Type Aliases

type ASTKindToNode

type ASTKindToNode = {
    [NodeT in ASTNode as NodeT['kind']]: NodeT;
};

Utility type listing all nodes indexed by their kind.

type ASTNode

type ASTNode =
    | NameNode
    | DocumentNode
    | OperationDefinitionNode
    | VariableDefinitionNode
    | VariableNode
    | SelectionSetNode
    | FieldNode
    | ArgumentNode
    | FragmentArgumentNode
    | FragmentSpreadNode
    | InlineFragmentNode
    | FragmentDefinitionNode
    | IntValueNode
    | FloatValueNode
    | StringValueNode
    | BooleanValueNode
    | NullValueNode
    | EnumValueNode
    | ListValueNode
    | ObjectValueNode
    | ObjectFieldNode
    | DirectiveNode
    | NamedTypeNode
    | ListTypeNode
    | NonNullTypeNode
    | SchemaDefinitionNode
    | OperationTypeDefinitionNode
    | ScalarTypeDefinitionNode
    | ObjectTypeDefinitionNode
    | FieldDefinitionNode
    | InputValueDefinitionNode
    | InterfaceTypeDefinitionNode
    | UnionTypeDefinitionNode
    | EnumTypeDefinitionNode
    | EnumValueDefinitionNode
    | InputObjectTypeDefinitionNode
    | DirectiveDefinitionNode
    | SchemaExtensionNode
    | ScalarTypeExtensionNode
    | ObjectTypeExtensionNode
    | InterfaceTypeExtensionNode
    | UnionTypeExtensionNode
    | EnumTypeExtensionNode
    | InputObjectTypeExtensionNode
    | DirectiveExtensionNode
    | TypeCoordinateNode
    | MemberCoordinateNode
    | ArgumentCoordinateNode
    | DirectiveCoordinateNode
    | DirectiveArgumentCoordinateNode;

The list of all possible AST node types.

type ASTVisitFn

type ASTVisitFn<TVisitedNode extends ASTNode> = (
    /** Current node being visited. */
    node: TVisitedNode,
    /** Index or key for this node within the parent node or array. */
    key: string | number | undefined,
    /** Parent immediately above this node, which may be an array. */
    parent: ASTNode | ReadonlyArray<ASTNode> | undefined,
    /** Key path from the root node to this node. */
    path: ReadonlyArray<string | number>,
    /**
     * All nodes and arrays visited before reaching this node's parent.
     * These correspond to array indices in `path`.
     * Note: ancestors includes arrays that contain the visited node's parent.
     */
    ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>
) => any;

A visitor is composed of visit functions called for each node during traversal.

type ASTVisitor

type ASTVisitor = EnterLeaveVisitor<ASTNode> | KindVisitor;

A visitor defines the callbacks called during AST traversal.

type ASTVisitorKeyMap

type ASTVisitorKeyMap = {
    [NodeT in ASTNode as NodeT['kind']]?: ReadonlyArray<keyof NodeT>;
};

A visitor key map describes the traversable child properties for each node kind.

type BreakingChangeType

type BreakingChangeType =
    (typeof BreakingChangeType)[keyof typeof BreakingChangeType];

Categories of schema changes that may break existing operations.

type ConstValueNode

type ConstValueNode =
    | IntValueNode
    | FloatValueNode
    | StringValueNode
    | BooleanValueNode
    | NullValueNode
    | EnumValueNode
    | ConstListValueNode
    | ConstObjectValueNode;

Any value literal that is guaranteed not to contain a variable reference.

type DangerousChangeType

type DangerousChangeType =
    (typeof DangerousChangeType)[keyof typeof DangerousChangeType];

Categories of schema changes that may be dangerous for existing operations.

type DefinitionNode

type DefinitionNode =
    | ExecutableDefinitionNode
    | TypeSystemDefinitionNode
    | TypeSystemExtensionNode;

Any top-level definition that may appear in a GraphQL document.

type DirectiveLocation

type DirectiveLocation = (typeof DirectiveLocation)[keyof typeof DirectiveLocation];

The set of allowed directive location values.

type ExecutableDefinitionNode

type ExecutableDefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;

Any executable definition that may appear in an operation document.

type FormattedIncrementalResult

type FormattedIncrementalResult<
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> =
    | FormattedIncrementalDeferResult<TDeferredData, TExtensions>
    | FormattedIncrementalStreamResult<TStreamItem, TExtensions>;

JSON-serializable deferred fragment or streamed list payload.

type FormattedLegacyIncrementalResult

type FormattedLegacyIncrementalResult<
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> =
    | FormattedLegacyIncrementalDeferResult<TDeferredData, TExtensions>
    | FormattedLegacyIncrementalStreamResult<TStreamItem, TExtensions>;

JSON-serializable deferred fragment or streamed list payload produced by legacy incremental execution.

type GraphQLAbstractType

type GraphQLAbstractType = GraphQLInterfaceType | GraphQLUnionType;

These types may describe the parent context of a selection set.

type GraphQLCompositeType

type GraphQLCompositeType =
    | GraphQLObjectType
    | GraphQLInterfaceType
    | GraphQLUnionType;

These types may describe the parent context of a selection set.

type GraphQLDefaultInput

type GraphQLDefaultInput =
    | {
          /** Runtime default value. */
          value: unknown;
          /** GraphQL literal default value is not provided in this variant. */
          literal?: never;
      }
    | {
          /** GraphQL literal default value. */
          literal: ConstValueNode;
          /** Runtime default value is not provided in this variant. */
          value?: never;
      };

Default input represented as either a runtime value or a GraphQL literal.

type GraphQLEnumValueConfigMap

type GraphQLEnumValueConfigMap = ObjMap<GraphQLEnumValueConfig>;

A map of enum value names to enum value configuration objects.

type GraphQLExecuteFn

type GraphQLExecuteFn = (
    ...args: Parameters<typeof execute>
) => ReturnType<typeof execute>;

Function used by a GraphQL harness to execute a valid operation.

type GraphQLFieldConfigArgumentMap

type GraphQLFieldConfigArgumentMap = ObjMap<GraphQLArgumentConfig>;

A map of argument names to argument configuration objects.

type GraphQLFieldConfigMap

type GraphQLFieldConfigMap<TSource, TContext> = ObjMap<
    GraphQLFieldConfig<TSource, TContext>
>;

A map of field names to field configuration objects.

type GraphQLFieldMap

type GraphQLFieldMap<TSource, TContext> = ObjMap<GraphQLField<TSource, TContext>>;

A map of field names to resolved field definitions.

type GraphQLFieldResolver

type GraphQLFieldResolver<TSource, TContext, TArgs = any, TResult = unknown> = (
    source: TSource,
    args: TArgs,
    context: TContext,
    info: GraphQLResolveInfo
) => TResult;

Resolves the runtime value for a GraphQL field.

type GraphQLInputFieldConfigMap

type GraphQLInputFieldConfigMap = ObjMap<GraphQLInputFieldConfig>;

A map of input field names to input field configuration objects.

type GraphQLInputFieldMap

type GraphQLInputFieldMap = ObjMap<GraphQLInputField>;

A map of input field names to resolved input field definitions.

type GraphQLInputType

type GraphQLInputType =
    | GraphQLNullableInputType
    | GraphQLNonNull<GraphQLNullableInputType>;

These types may be used as input types for arguments and directives.

type GraphQLIsTypeOfFn

type GraphQLIsTypeOfFn<TAbstract, TContext> = (
    value: TAbstract,
    context: TContext,
    info: GraphQLResolveInfo
) => PromiseOrValue<boolean>;

Checks whether a runtime value belongs to a GraphQL object type.

type GraphQLLeafType

type GraphQLLeafType = GraphQLScalarType | GraphQLEnumType;

These types may describe types which may be leaf values.

type GraphQLNamedInputType

type GraphQLNamedInputType =
    | GraphQLScalarType
    | GraphQLEnumType
    | GraphQLInputObjectType;

A named GraphQL type that can be used as an input type.

type GraphQLNamedOutputType

type GraphQLNamedOutputType =
    | GraphQLScalarType
    | GraphQLObjectType
    | GraphQLInterfaceType
    | GraphQLUnionType
    | GraphQLEnumType;

A named GraphQL type that can be used as an output type.

type GraphQLNamedType

type GraphQLNamedType = GraphQLNamedInputType | GraphQLNamedOutputType;

These named types do not include modifiers like List or NonNull.

type GraphQLNullableInputType

type GraphQLNullableInputType =
    | GraphQLNamedInputType
    | GraphQLList<GraphQLInputType>;

These types may be used as input types for arguments and directives.

type GraphQLNullableOutputType

type GraphQLNullableOutputType =
    | GraphQLNamedOutputType
    | GraphQLList<GraphQLOutputType>;

These types may be used as output types as the result of fields.

type GraphQLNullableType

type GraphQLNullableType = GraphQLNamedType | GraphQLList<GraphQLType>;

These types can all accept null as a value.

type GraphQLOutputType

type GraphQLOutputType =
    | GraphQLNullableOutputType
    | GraphQLNonNull<GraphQLNullableOutputType>;

These types may be used as output types as the result of fields.

type GraphQLParseFn

type GraphQLParseFn = (
    ...args: Parameters<typeof parse>
) => PromiseOrValue<ReturnType<typeof parse>>;

Function used by a GraphQL harness to parse GraphQL source text.

type GraphQLScalarInputLiteralCoercer

type GraphQLScalarInputLiteralCoercer<TInternal> = (
    valueNode: ConstValueNode
) => Maybe<TInternal>;

Function used to coerce GraphQL scalar input literals.

type GraphQLScalarInputValueCoercer

type GraphQLScalarInputValueCoercer<TInternal> = (inputValue: unknown) => TInternal;

Function used to coerce externally provided scalar input values.

type GraphQLScalarLiteralParser

type GraphQLScalarLiteralParser<TInternal> = (
    valueNode: ValueNode,
    variables: Maybe<ObjMap<unknown>>
) => Maybe<TInternal>;

Deprecated function type that parses a GraphQL value literal as a scalar input value. Use GraphQLScalarInputLiteralCoercer instead.
Deprecated
Use GraphQLScalarInputLiteralCoercer instead. Will be removed in v18.

type GraphQLScalarOutputValueCoercer

type GraphQLScalarOutputValueCoercer<TExternal> = (
    outputValue: unknown
) => TExternal;

Function used to coerce internal scalar values for response output.

type GraphQLScalarSerializer

type GraphQLScalarSerializer<TExternal> = (outputValue: unknown) => TExternal;

Deprecated function type that serializes a runtime value as a scalar output value. Use GraphQLScalarOutputValueCoercer instead.
Deprecated
Use GraphQLScalarOutputValueCoercer instead. Will be removed in v18.

type GraphQLScalarValueParser

type GraphQLScalarValueParser<TInternal> = (inputValue: unknown) => TInternal;

Deprecated function type that parses a runtime input value as a scalar input value. Use GraphQLScalarInputValueCoercer instead.
Deprecated
Use GraphQLScalarInputValueCoercer instead. Will be removed in v18.

type GraphQLSubscribeFn

type GraphQLSubscribeFn = (
    ...args: Parameters<typeof subscribe>
) => ReturnType<typeof subscribe>;

Function used by a GraphQL harness to create a subscription response stream.

type GraphQLType

type GraphQLType = GraphQLNamedType | GraphQLWrappingType;

These are all of the possible kinds of types.

type GraphQLTypeResolver

type GraphQLTypeResolver<TSource, TContext> = (
    value: TSource,
    context: TContext,
    info: GraphQLResolveInfo,
    abstractType: GraphQLAbstractType
) => PromiseOrValue<string | undefined>;

Resolves the concrete object type for an abstract GraphQL type.

type GraphQLValidateFn

type GraphQLValidateFn = (
    ...args: Parameters<typeof validate>
) => PromiseOrValue<ReturnType<typeof validate>>;

Function used by a GraphQL harness to validate a parsed document.

type GraphQLWrappingType

type GraphQLWrappingType =
    | GraphQLList<GraphQLType>
    | GraphQLNonNull<GraphQLNullableType>;

These types wrap and modify other types

type IncrementalResult

type IncrementalResult<
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> =
    | IncrementalDeferResult<TDeferredData, TExtensions>
    | IncrementalStreamResult<TStreamItem, TExtensions>;

Deferred fragment or streamed list payload produced by incremental execution.

type IntrospectionInputType

type IntrospectionInputType =
    | IntrospectionScalarType
    | IntrospectionEnumType
    | IntrospectionInputObjectType;

An introspection type that can appear in input position.

type IntrospectionInputTypeRef

type IntrospectionInputTypeRef =
    | IntrospectionNamedTypeRef<IntrospectionInputType>
    | IntrospectionListTypeRef<IntrospectionInputTypeRef>
    | IntrospectionNonNullTypeRef<
          | IntrospectionNamedTypeRef<IntrospectionInputType>
          | IntrospectionListTypeRef<IntrospectionInputTypeRef>
      >;

An introspection type reference that can appear in input position.

type IntrospectionOutputType

type IntrospectionOutputType =
    | IntrospectionScalarType
    | IntrospectionObjectType
    | IntrospectionInterfaceType
    | IntrospectionUnionType
    | IntrospectionEnumType;

An introspection type that can appear in output position.

type IntrospectionOutputTypeRef

type IntrospectionOutputTypeRef =
    | IntrospectionNamedTypeRef<IntrospectionOutputType>
    | IntrospectionListTypeRef<IntrospectionOutputTypeRef>
    | IntrospectionNonNullTypeRef<
          | IntrospectionNamedTypeRef<IntrospectionOutputType>
          | IntrospectionListTypeRef<IntrospectionOutputTypeRef>
      >;

An introspection type reference that can appear in output position.

type IntrospectionType

type IntrospectionType =
    | IntrospectionScalarType
    | IntrospectionObjectType
    | IntrospectionInterfaceType
    | IntrospectionUnionType
    | IntrospectionEnumType
    | IntrospectionInputObjectType;

Any introspection representation of a GraphQL type.

type IntrospectionTypeRef

type IntrospectionTypeRef =
    | IntrospectionNamedTypeRef
    | IntrospectionListTypeRef
    | IntrospectionNonNullTypeRef<
          IntrospectionNamedTypeRef | IntrospectionListTypeRef
      >;

Any introspection representation of a type reference.

type Kind

type Kind = (typeof Kind_)[keyof typeof Kind_];

The set of allowed kind values for AST nodes.

type LegacyIncrementalResult

type LegacyIncrementalResult<
    TDeferredData = ObjMap<unknown>,
    TStreamItem = unknown,
    TExtensions = ObjMap<unknown>
> =
    | LegacyIncrementalDeferResult<TDeferredData, TExtensions>
    | LegacyIncrementalStreamResult<TStreamItem, TExtensions>;

Deferred fragment or streamed list payload produced by legacy incremental execution.

type OperationTypeNode

type OperationTypeNode = (typeof OperationTypeNode)[keyof typeof OperationTypeNode];

The operation types supported by GraphQL executable definitions. Kinds

type ResolvedSchemaElement

type ResolvedSchemaElement =
    | ResolvedNamedType
    | ResolvedField
    | ResolvedInputField
    | ResolvedEnumValue
    | ResolvedFieldArgument
    | ResolvedDirective
    | ResolvedDirectiveArgument;

A schema element resolved from a schema coordinate.

type RootSelectionSetExecutor

type RootSelectionSetExecutor = (
    validatedExecutionArgs: ValidatedSubscriptionArgs
) => PromiseOrValue<ExecutionResult>;

Function used to execute a validated root selection set for a subscription event.

type SafeChangeType

type SafeChangeType = (typeof SafeChangeType)[keyof typeof SafeChangeType];

Categories of schema changes that are considered safe for existing operations.

type SchemaChange

type SchemaChange = SafeChange | DangerousChange | BreakingChange;

Any schema change detected between two schemas.

type SchemaCoordinateNode

type SchemaCoordinateNode =
    | TypeCoordinateNode
    | MemberCoordinateNode
    | ArgumentCoordinateNode
    | DirectiveCoordinateNode
    | DirectiveArgumentCoordinateNode;

Any AST node representing a GraphQL schema coordinate.

type SelectionNode

type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;

Any selection that may appear inside a selection set.

type ThunkObjMap

type ThunkObjMap<T> = (() => ObjMap<T>) | ObjMap<T>;

A thunk that resolves to an object map.

type ThunkReadonlyArray

type ThunkReadonlyArray<T> = (() => ReadonlyArray<T>) | ReadonlyArray<T>;

Used while defining GraphQL types to allow for circular references in otherwise immutable type definitions.

type TokenKind

type TokenKind = (typeof TokenKind)[keyof typeof TokenKind];

An exported enum describing the different kinds of tokens that the lexer emits.

type TypeDefinitionNode

type TypeDefinitionNode =
    | ScalarTypeDefinitionNode
    | ObjectTypeDefinitionNode
    | InterfaceTypeDefinitionNode
    | UnionTypeDefinitionNode
    | EnumTypeDefinitionNode
    | InputObjectTypeDefinitionNode;

Any named type definition that may appear in a schema document.

type TypeExtensionNode

type TypeExtensionNode =
    | ScalarTypeExtensionNode
    | ObjectTypeExtensionNode
    | InterfaceTypeExtensionNode
    | UnionTypeExtensionNode
    | EnumTypeExtensionNode
    | InputObjectTypeExtensionNode;

Any named type extension that may appear in a schema extension document.

type TypeKind

type TypeKind = (typeof TypeKind)[keyof typeof TypeKind];

The introspection enum describing the different kinds of GraphQL types. Introspection

type TypeNode

type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;

Any GraphQL type reference AST node.

type TypeSystemDefinitionNode

type TypeSystemDefinitionNode =
    | SchemaDefinitionNode
    | TypeDefinitionNode
    | DirectiveDefinitionNode;

Any type-system definition that may appear in a schema document.

type TypeSystemExtensionNode

type TypeSystemExtensionNode =
    | SchemaExtensionNode
    | TypeExtensionNode
    | DirectiveExtensionNode;

Any type-system extension that may appear in a schema extension document.

type ValidationRule

type ValidationRule = (context: ValidationContext) => ASTVisitor;

A function that creates an AST visitor for validating a GraphQL document.

type ValueNode

type ValueNode =
    | VariableNode
    | IntValueNode
    | FloatValueNode
    | StringValueNode
    | BooleanValueNode
    | NullValueNode
    | EnumValueNode
    | ListValueNode
    | ObjectValueNode;

Any value literal that may appear in an executable GraphQL document.

Namespaces

namespace Kind

module 'language/kinds_.d.ts' {}

Kinds

variable ARGUMENT

const ARGUMENT: string;

AST kind for argument nodes.

variable ARGUMENT_COORDINATE

const ARGUMENT_COORDINATE: string;

AST kind for argument coordinate nodes.

variable BOOLEAN

const BOOLEAN: string;

AST kind for boolean value nodes.

variable DIRECTIVE

const DIRECTIVE: string;

AST kind for directive nodes.

variable DIRECTIVE_ARGUMENT_COORDINATE

const DIRECTIVE_ARGUMENT_COORDINATE: string;

AST kind for directive argument coordinate nodes.

variable DIRECTIVE_COORDINATE

const DIRECTIVE_COORDINATE: string;

AST kind for directive coordinate nodes.

variable DIRECTIVE_DEFINITION

const DIRECTIVE_DEFINITION: string;

AST kind for directive definition nodes.

variable DIRECTIVE_EXTENSION

const DIRECTIVE_EXTENSION: string;

AST kind for directive extension nodes.

variable DOCUMENT

const DOCUMENT: string;

AST kind for document nodes.

variable ENUM

const ENUM: string;

AST kind for enum value nodes.

variable ENUM_TYPE_DEFINITION

const ENUM_TYPE_DEFINITION: string;

AST kind for enum type definition nodes.

variable ENUM_TYPE_EXTENSION

const ENUM_TYPE_EXTENSION: string;

AST kind for enum type extension nodes.

variable ENUM_VALUE_DEFINITION

const ENUM_VALUE_DEFINITION: string;

AST kind for enum value definition nodes.

variable FIELD

const FIELD: string;

AST kind for field selection nodes.

variable FIELD_DEFINITION

const FIELD_DEFINITION: string;

AST kind for field definition nodes.

variable FLOAT

const FLOAT: string;

AST kind for floating-point value nodes.

variable FRAGMENT_ARGUMENT

const FRAGMENT_ARGUMENT: string;

AST kind for fragment argument nodes.

variable FRAGMENT_DEFINITION

const FRAGMENT_DEFINITION: string;

AST kind for fragment definition nodes.

variable FRAGMENT_SPREAD

const FRAGMENT_SPREAD: string;

AST kind for fragment spread nodes.

variable INLINE_FRAGMENT

const INLINE_FRAGMENT: string;

AST kind for inline fragment nodes.

variable INPUT_OBJECT_TYPE_DEFINITION

const INPUT_OBJECT_TYPE_DEFINITION: string;

AST kind for input object type definition nodes.

variable INPUT_OBJECT_TYPE_EXTENSION

const INPUT_OBJECT_TYPE_EXTENSION: string;

AST kind for input object type extension nodes.

variable INPUT_VALUE_DEFINITION

const INPUT_VALUE_DEFINITION: string;

AST kind for input value definition nodes.

variable INT

const INT: string;

AST kind for integer value nodes.

variable INTERFACE_TYPE_DEFINITION

const INTERFACE_TYPE_DEFINITION: string;

AST kind for interface type definition nodes.

variable INTERFACE_TYPE_EXTENSION

const INTERFACE_TYPE_EXTENSION: string;

AST kind for interface type extension nodes.

variable LIST

const LIST: string;

AST kind for list value nodes.

variable LIST_TYPE

const LIST_TYPE: string;

AST kind for list type reference nodes.

variable MEMBER_COORDINATE

const MEMBER_COORDINATE: string;

AST kind for member coordinate nodes.

variable NAME

const NAME: string;

AST kind for name nodes.

variable NAMED_TYPE

const NAMED_TYPE: string;

AST kind for named type reference nodes.

variable NON_NULL_TYPE

const NON_NULL_TYPE: string;

AST kind for non-null type reference nodes.

variable NULL

const NULL: string;

AST kind for null value nodes.

variable OBJECT

const OBJECT: string;

AST kind for object value nodes.

variable OBJECT_FIELD

const OBJECT_FIELD: string;

AST kind for object field nodes.

variable OBJECT_TYPE_DEFINITION

const OBJECT_TYPE_DEFINITION: string;

AST kind for object type definition nodes.

variable OBJECT_TYPE_EXTENSION

const OBJECT_TYPE_EXTENSION: string;

AST kind for object type extension nodes.

variable OPERATION_DEFINITION

const OPERATION_DEFINITION: string;

AST kind for operation definition nodes.

variable OPERATION_TYPE_DEFINITION

const OPERATION_TYPE_DEFINITION: string;

AST kind for operation type definition nodes.

variable SCALAR_TYPE_DEFINITION

const SCALAR_TYPE_DEFINITION: string;

AST kind for scalar type definition nodes.

variable SCALAR_TYPE_EXTENSION

const SCALAR_TYPE_EXTENSION: string;

AST kind for scalar type extension nodes.

variable SCHEMA_DEFINITION

const SCHEMA_DEFINITION: string;

AST kind for schema definition nodes.

variable SCHEMA_EXTENSION

const SCHEMA_EXTENSION: string;

AST kind for schema extension nodes.

variable SELECTION_SET

const SELECTION_SET: string;

AST kind for selection set nodes.

variable STRING

const STRING: string;

AST kind for string value nodes.

variable TYPE_COORDINATE

const TYPE_COORDINATE: string;

AST kind for type coordinate nodes.

variable UNION_TYPE_DEFINITION

const UNION_TYPE_DEFINITION: string;

AST kind for union type definition nodes.

variable UNION_TYPE_EXTENSION

const UNION_TYPE_EXTENSION: string;

AST kind for union type extension nodes.

variable VARIABLE

const VARIABLE: string;

AST kind for variable reference nodes.

variable VARIABLE_DEFINITION

const VARIABLE_DEFINITION: string;

AST kind for variable definition nodes.

type ARGUMENT

type ARGUMENT = typeof ARGUMENT;

Type of the Kind.ARGUMENT AST kind value.

type ARGUMENT_COORDINATE

type ARGUMENT_COORDINATE = typeof ARGUMENT_COORDINATE;

Type of the Kind.ARGUMENT_COORDINATE AST kind value.

type BOOLEAN

type BOOLEAN = typeof BOOLEAN;

Type of the Kind.BOOLEAN AST kind value.

type DIRECTIVE

type DIRECTIVE = typeof DIRECTIVE;

Type of the Kind.DIRECTIVE AST kind value.

type DIRECTIVE_ARGUMENT_COORDINATE

type DIRECTIVE_ARGUMENT_COORDINATE = typeof DIRECTIVE_ARGUMENT_COORDINATE;

Type of the Kind.DIRECTIVE_ARGUMENT_COORDINATE AST kind value.

type DIRECTIVE_COORDINATE

type DIRECTIVE_COORDINATE = typeof DIRECTIVE_COORDINATE;

Type of the Kind.DIRECTIVE_COORDINATE AST kind value.

type DIRECTIVE_DEFINITION

type DIRECTIVE_DEFINITION = typeof DIRECTIVE_DEFINITION;

Type of the Kind.DIRECTIVE_DEFINITION AST kind value.

type DIRECTIVE_EXTENSION

type DIRECTIVE_EXTENSION = typeof DIRECTIVE_EXTENSION;

Type of the Kind.DIRECTIVE_EXTENSION AST kind value.

type DOCUMENT

type DOCUMENT = typeof DOCUMENT;

Type of the Kind.DOCUMENT AST kind value.

type ENUM

type ENUM = typeof ENUM;

Type of the Kind.ENUM AST kind value.

type ENUM_TYPE_EXTENSION

type ENUM_TYPE_EXTENSION = typeof ENUM_TYPE_EXTENSION;

Type of the Kind.ENUM_TYPE_EXTENSION AST kind value.

type ENUM_VALUE_DEFINITION

type ENUM_VALUE_DEFINITION = typeof ENUM_VALUE_DEFINITION;

Type of the Kind.ENUM_VALUE_DEFINITION AST kind value.

type FIELD

type FIELD = typeof FIELD;

Type of the Kind.FIELD AST kind value.

type FIELD_DEFINITION

type FIELD_DEFINITION = typeof FIELD_DEFINITION;

Type of the Kind.FIELD_DEFINITION AST kind value.

type FLOAT

type FLOAT = typeof FLOAT;

Type of the Kind.FLOAT AST kind value.

type FRAGMENT_ARGUMENT

type FRAGMENT_ARGUMENT = typeof FRAGMENT_ARGUMENT;

Type of the Kind.FRAGMENT_ARGUMENT AST kind value.

type FRAGMENT_DEFINITION

type FRAGMENT_DEFINITION = typeof FRAGMENT_DEFINITION;

Type of the Kind.FRAGMENT_DEFINITION AST kind value.

type FRAGMENT_SPREAD

type FRAGMENT_SPREAD = typeof FRAGMENT_SPREAD;

Type of the Kind.FRAGMENT_SPREAD AST kind value.

type INLINE_FRAGMENT

type INLINE_FRAGMENT = typeof INLINE_FRAGMENT;

Type of the Kind.INLINE_FRAGMENT AST kind value.

type INPUT_OBJECT_TYPE_DEFINITION

type INPUT_OBJECT_TYPE_DEFINITION = typeof INPUT_OBJECT_TYPE_DEFINITION;

Type of the Kind.INPUT_OBJECT_TYPE_DEFINITION AST kind value.

type INPUT_OBJECT_TYPE_EXTENSION

type INPUT_OBJECT_TYPE_EXTENSION = typeof INPUT_OBJECT_TYPE_EXTENSION;

Type of the Kind.INPUT_OBJECT_TYPE_EXTENSION AST kind value.

type INPUT_VALUE_DEFINITION

type INPUT_VALUE_DEFINITION = typeof INPUT_VALUE_DEFINITION;

Type of the Kind.INPUT_VALUE_DEFINITION AST kind value.

type INT

type INT = typeof INT;

Type of the Kind.INT AST kind value.

type INTERFACE_TYPE_DEFINITION

type INTERFACE_TYPE_DEFINITION = typeof INTERFACE_TYPE_DEFINITION;

Type of the Kind.INTERFACE_TYPE_DEFINITION AST kind value.

type INTERFACE_TYPE_EXTENSION

type INTERFACE_TYPE_EXTENSION = typeof INTERFACE_TYPE_EXTENSION;

Type of the Kind.INTERFACE_TYPE_EXTENSION AST kind value.

type LIST

type LIST = typeof LIST;

Type of the Kind.LIST AST kind value.

type LIST_TYPE

type LIST_TYPE = typeof LIST_TYPE;

Type of the Kind.LIST_TYPE AST kind value.

type MEMBER_COORDINATE

type MEMBER_COORDINATE = typeof MEMBER_COORDINATE;

Type of the Kind.MEMBER_COORDINATE AST kind value.

type NAME

type NAME = typeof NAME;

Type of the Kind.NAME AST kind value.

type NAMED_TYPE

type NAMED_TYPE = typeof NAMED_TYPE;

Type of the Kind.NAMED_TYPE AST kind value.

type NON_NULL_TYPE

type NON_NULL_TYPE = typeof NON_NULL_TYPE;

Type of the Kind.NON_NULL_TYPE AST kind value.

type NULL

type NULL = typeof NULL;

Type of the Kind.NULL AST kind value.

type OBJECT

type OBJECT = typeof OBJECT;

Type of the Kind.OBJECT AST kind value.

type OBJECT_FIELD

type OBJECT_FIELD = typeof OBJECT_FIELD;

Type of the Kind.OBJECT_FIELD AST kind value.

type OBJECT_TYPE_DEFINITION

type OBJECT_TYPE_DEFINITION = typeof OBJECT_TYPE_DEFINITION;

Type of the Kind.OBJECT_TYPE_DEFINITION AST kind value.

type OBJECT_TYPE_EXTENSION

type OBJECT_TYPE_EXTENSION = typeof OBJECT_TYPE_EXTENSION;

Type of the Kind.OBJECT_TYPE_EXTENSION AST kind value.

type OPERATION_DEFINITION

type OPERATION_DEFINITION = typeof OPERATION_DEFINITION;

Type of the Kind.OPERATION_DEFINITION AST kind value.

type OPERATION_TYPE_DEFINITION

type OPERATION_TYPE_DEFINITION = typeof OPERATION_TYPE_DEFINITION;

Type of the Kind.OPERATION_TYPE_DEFINITION AST kind value.

type SCALAR_TYPE_DEFINITION

type SCALAR_TYPE_DEFINITION = typeof SCALAR_TYPE_DEFINITION;

Type of the Kind.SCALAR_TYPE_DEFINITION AST kind value.

type SCALAR_TYPE_EXTENSION

type SCALAR_TYPE_EXTENSION = typeof SCALAR_TYPE_EXTENSION;

Type of the Kind.SCALAR_TYPE_EXTENSION AST kind value.

type SCHEMA_DEFINITION

type SCHEMA_DEFINITION = typeof SCHEMA_DEFINITION;

Type of the Kind.SCHEMA_DEFINITION AST kind value.

type SCHEMA_EXTENSION

type SCHEMA_EXTENSION = typeof SCHEMA_EXTENSION;

Type of the Kind.SCHEMA_EXTENSION AST kind value.

type SELECTION_SET

type SELECTION_SET = typeof SELECTION_SET;

Type of the Kind.SELECTION_SET AST kind value.

type STRING

type STRING = typeof STRING;

Type of the Kind.STRING AST kind value.

type TYPE_COORDINATE

type TYPE_COORDINATE = typeof TYPE_COORDINATE;

Type of the Kind.TYPE_COORDINATE AST kind value.

type UNION_TYPE_DEFINITION

type UNION_TYPE_DEFINITION = typeof UNION_TYPE_DEFINITION;

Type of the Kind.UNION_TYPE_DEFINITION AST kind value.

type UNION_TYPE_EXTENSION

type UNION_TYPE_EXTENSION = typeof UNION_TYPE_EXTENSION;

Type of the Kind.UNION_TYPE_EXTENSION AST kind value.

type VARIABLE

type VARIABLE = typeof VARIABLE;

Type of the Kind.VARIABLE AST kind value.

type VARIABLE_DEFINITION

type VARIABLE_DEFINITION = typeof VARIABLE_DEFINITION;

Type of the Kind.VARIABLE_DEFINITION AST kind value.

Package Files (107)

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/graphql.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/graphql)

HTML

<a href="https://www.jsdocs.io/package/graphql"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 3 seconds ago.
Package analyzed in 16568 ms.
Missing or incorrect documentation? Open an issue for this package.