Type | GraphQL

Create and inspect GraphQL type definitions and schemas.

These exports are also available from the root graphql package.

For documentation purposes, these exports are grouped into the following categories:

Category: Paths

Types:
ResponsePath

Types

ResponsePath

Interface. Represents a linked response path from a field back to the root response.

Members

Name	Type	Description
prev	`Path \| undefined`	The previous segment in the linked response path, or undefined at the root.
key	`string \| number`	The field name or list index for this response path segment.
typename	`string \| undefined`	The runtime object type name associated with this path segment, if known.

Category: Names

Functions:
assertName()assertEnumValueName()

Functions

assertName()

Upholds the spec rules about naming.

Signature:

assertName(name: string): string;

Arguments

Name	Type	Description
name	`string`	The GraphQL name to validate.

Returns

Type	Description
`string`	The validated GraphQL name.

Example

import { assertName } from 'graphql/type';
 
assertName('User'); // => 'User'
assertName('123User'); // throws an error

assertEnumValueName()

Upholds the spec rules about naming enum values.

Signature:

assertEnumValueName(name: string): string;

Arguments

Name	Type	Description
name	`string`	The GraphQL name to validate.

Returns

Type	Description
`string`	The validated GraphQL name.

Example

import { assertEnumValueName } from 'graphql/type';
 
assertEnumValueName('ACTIVE'); // => 'ACTIVE'
assertEnumValueName('true'); // throws an error

Category: Types

Classes:
GraphQLList GraphQLNonNull GraphQLScalarType GraphQLObjectType GraphQLInterfaceType GraphQLUnionType GraphQLEnumType GraphQLInputObjectType

Functions:
isType()assertType()isScalarType()assertScalarType()isObjectType()assertObjectType()isInterfaceType()assertInterfaceType()isUnionType()assertUnionType()isEnumType()assertEnumType()isInputObjectType()assertInputObjectType()isListType()assertListType()isNonNullType()assertNonNullType()isInputType()assertInputType()isOutputType()assertOutputType()isLeafType()assertLeafType()isCompositeType()assertCompositeType()isAbstractType()assertAbstractType()isWrappingType()assertWrappingType()isNullableType()assertNullableType()getNullableType()isNamedType()assertNamedType()getNamedType()resolveReadonlyArrayThunk()resolveObjMapThunk()isRequiredArgument()isRequiredInputField()

Types:
GraphQLType GraphQLInputType GraphQLOutputType GraphQLLeafType GraphQLCompositeType GraphQLAbstractType GraphQLWrappingType GraphQLNullableType GraphQLNamedType GraphQLNamedInputType GraphQLNamedOutputType ThunkReadonlyArray ThunkObjMap GraphQLScalarTypeExtensions GraphQLScalarSerializer GraphQLScalarValueParser GraphQLScalarLiteralParser GraphQLScalarTypeConfig GraphQLObjectTypeExtensions GraphQLObjectTypeConfig GraphQLTypeResolver GraphQLIsTypeOfFn GraphQLFieldResolver GraphQLResolveInfo GraphQLFieldExtensions GraphQLFieldConfig GraphQLFieldConfigArgumentMap GraphQLArgumentExtensions GraphQLArgumentConfig GraphQLFieldConfigMap GraphQLField GraphQLArgument GraphQLFieldMap GraphQLInterfaceTypeExtensions GraphQLInterfaceTypeConfig GraphQLUnionTypeExtensions GraphQLUnionTypeConfig GraphQLEnumTypeExtensions GraphQLEnumTypeConfig GraphQLEnumValueConfigMap GraphQLEnumValueExtensions GraphQLEnumValueConfig GraphQLEnumValue GraphQLInputObjectTypeExtensions GraphQLInputObjectTypeConfig GraphQLInputFieldExtensions GraphQLInputFieldConfig GraphQLInputFieldConfigMap GraphQLInputField GraphQLInputFieldMap

Classes

GraphQLList

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.

Type Parameters

Name	Constraint	Default	Description
T	`GraphQLType`		The GraphQL type wrapped by this list type.

Example

const PersonType = new GraphQLObjectType({
  name: 'Person',
  fields: () => ({
    parents: { type: new GraphQLList(PersonType) },
    children: { type: new GraphQLList(PersonType) },
  })
})

Constructor

Creates a GraphQLList instance.

Signature:

new GraphQLList(ofType: T);

Arguments

Name	Type	Description
ofType	`T`	The type to wrap.

Members

Name	Type	Description
ofType	`T`	The type wrapped by this list or non-null type.

toString()

Returns this wrapping type as a GraphQL type-reference string.

Signature:

toString(): string;

Returns

Type	Description
`string`	The GraphQL type-reference string.

Example

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!]'

toJSON()

Returns the JSON representation used when this object is serialized.

Signature:

toJSON(): string;

Returns

Type	Description
`string`	The JSON-serializable representation.

Example

import { GraphQLList, GraphQLString } from 'graphql/type';
 
const stringList = new GraphQLList(GraphQLString);
 
stringList.toJSON(); // => '[String]'
JSON.stringify({ type: stringList }); // => '{"type":"[String]"}'

GraphQLNonNull

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.

Type Parameters

Name	Constraint	Default	Description
T	`GraphQLNullableType`		The nullable GraphQL type wrapped by this non-null type.

Example

const RowType = new GraphQLObjectType({
  name: 'Row',
  fields: () => ({
    id: { type: new GraphQLNonNull(GraphQLString) },
  })
})

Note: the enforcement of non-nullability occurs within the executor.

Constructor

Creates a GraphQLNonNull instance.

Signature:

new GraphQLNonNull(ofType: T);

Arguments

Name	Type	Description
ofType	`T`	The type to wrap.

Members

Name	Type	Description
ofType	`T`	The type wrapped by this list or non-null type.

toString()

Returns this wrapping type as a GraphQL type-reference string.

Signature:

toString(): string;

Returns

Type	Description
`string`	The GraphQL type-reference string.

Example

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]!'

toJSON()

Returns the JSON representation used when this object is serialized.

Signature:

toJSON(): string;

Returns

Type	Description
`string`	The JSON-serializable representation.

Example

import { GraphQLNonNull, GraphQLString } from 'graphql/type';
 
const requiredString = new GraphQLNonNull(GraphQLString);
 
requiredString.toJSON(); // => 'String!'
JSON.stringify({ type: requiredString }); // => '{"type":"String!"}'

GraphQLScalarType

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 serialize 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.

Type Parameters

Name	Constraint	Default	Description
TInternal		`unknown`	The internal runtime representation accepted by this scalar.
TExternal		`TInternal`	The serialized representation exposed in GraphQL results.

Example

const OddType = new GraphQLScalarType({
  name: 'Odd',
  serialize: (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;
  }
});

Constructor

Creates a GraphQLScalarType instance.

Signature:

new GraphQLScalarType(
  config: Readonly<
    GraphQLScalarTypeConfig<TInternal, TExternal>
  >,
);

Arguments

Name	Type	Description
config	`Readonly< GraphQLScalarTypeConfig<TInternal, TExternal> >`	Configuration describing this object.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
specifiedByURL	`Maybe<string>`	URL identifying the behavior specified for this custom scalar.
serialize	`GraphQLScalarSerializer<TExternal>`	Function that converts internal values to externally visible scalar values.
parseValue	`GraphQLScalarValueParser<TInternal>`	Function that converts variable input into this scalar’s internal value.
parseLiteral	`GraphQLScalarLiteralParser<TInternal>`	Function that converts AST input literals into this scalar’s internal value.
extensions	`Readonly<GraphQLScalarTypeExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<ScalarTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes	`readonly ScalarTypeExtensionNode[]`	AST extension nodes applied to this schema element.

toConfig()

Returns a normalized configuration object for this object.

Signature:

toConfig(): {
  serialize: GraphQLScalarSerializer<TExternal>;
  parseValue: GraphQLScalarValueParser<TInternal>;
  parseLiteral: GraphQLScalarLiteralParser<TInternal>;
  extensions: Readonly<GraphQLScalarTypeExtensions>;
  extensionASTNodes: ReadonlyArray<ScalarTypeExtensionNode>;
};

Returns

Type	Description
`{ serialize: GraphQLScalarSerializer<TExternal>; parseValue: GraphQLScalarValueParser<TInternal>; parseLiteral: GraphQLScalarLiteralParser<TInternal>; extensions: Readonly<GraphQLScalarTypeExtensions>; extensionASTNodes: ReadonlyArray<ScalarTypeExtensionNode>; }`	A configuration object that can be used to recreate this object.

Example

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

toString()

Returns the schema coordinate identifying this scalar type.

Signature:

toString(): string;

Returns

Type	Description
`string`	The schema coordinate for this scalar type.

Example

import { GraphQLScalarType } from 'graphql/type';
 
const DateTime = new GraphQLScalarType({ name: 'DateTime' });
 
DateTime.toString(); // => 'DateTime'
String(DateTime); // => 'DateTime'

toJSON()

Returns the JSON representation used when this object is serialized.

Signature:

toJSON(): string;

Returns

Type	Description
`string`	The JSON-serializable representation.

Example

import { GraphQLScalarType } from 'graphql/type';
 
const DateTime = new GraphQLScalarType({ name: 'DateTime' });
 
DateTime.toJSON(); // => 'DateTime'
JSON.stringify({ type: DateTime }); // => '{"type":"DateTime"}'

GraphQLObjectType

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.

Type Parameters

Name	Constraint	Default	Description
TSource		`any`	Source object type passed to resolvers.
TContext		`any`	Context object type passed to resolvers.

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

Creates a GraphQLObjectType instance.

Signature:

new GraphQLObjectType(
  config: Readonly<
    GraphQLObjectTypeConfig<TSource, TContext>
  >,
);

Arguments

Name	Type	Description
config	`Readonly< GraphQLObjectTypeConfig<TSource, TContext> >`	Configuration describing this object.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
isTypeOf	`Maybe< GraphQLIsTypeOfFn<TSource, TContext> >`	Predicate used to determine whether a runtime value belongs to this object type.
extensions	`Readonly< GraphQLObjectTypeExtensions<TSource, TContext> >`	Extension fields to include in the formatted result.
astNode	`Maybe<ObjectTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes	`readonly ObjectTypeExtensionNode[]`	AST extension nodes applied to this schema element.

getFields()

Returns the fields defined by this type.

Signature:

getFields(): GraphQLFieldMap<
  TSource,
  TContext
>;

Returns

Type	Description
`GraphQLFieldMap<TSource, TContext>`	The fields keyed by field name.

Example

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!'

getInterfaces()

Returns the interfaces implemented by this type.

Signature:

getInterfaces(): readonly GraphQLInterfaceType[];

Returns

Type	Description
`readonly GraphQLInterfaceType[]`	The implemented interfaces.

Example

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']

toConfig()

Returns a normalized configuration object for this object.

Signature:

toConfig(): {
  interfaces: ReadonlyArray<GraphQLInterfaceType>;
  fields: GraphQLFieldConfigMap<any, any>;
  extensions: Readonly<
    GraphQLObjectTypeExtensions<TSource, TContext>
  >;
  extensionASTNodes: ReadonlyArray<ObjectTypeExtensionNode>;
};

Returns

Type	Description
`{ interfaces: ReadonlyArray<GraphQLInterfaceType>; fields: GraphQLFieldConfigMap<any, any>; extensions: Readonly< GraphQLObjectTypeExtensions<TSource, TContext> >; extensionASTNodes: ReadonlyArray<ObjectTypeExtensionNode>; }`	A configuration object that can be used to recreate this object.

Example

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

toString()

Returns the schema coordinate identifying this object type.

Signature:

toString(): string;

Returns

Type	Description
`string`	The schema coordinate for this object type.

Example

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'

toJSON()

Returns the JSON representation used when this object is serialized.

Signature:

toJSON(): string;

Returns

Type	Description
`string`	The JSON-serializable representation.

Example

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"}'

GraphQLInterfaceType

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

const EntityType = new GraphQLInterfaceType({
  name: 'Entity',
  fields: {
    name: { type: GraphQLString }
  }
});

Constructor

Creates a GraphQLInterfaceType instance.

Signature:

new GraphQLInterfaceType(
  config: Readonly<GraphQLInterfaceTypeConfig<any, any>>,
);

Arguments

Name	Type	Description
config	`Readonly<GraphQLInterfaceTypeConfig<any, any>>`	Configuration describing this object.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
resolveType	`Maybe<GraphQLTypeResolver<any, any>>`	Function that resolves the concrete object type for this abstract type.
extensions	`Readonly<GraphQLInterfaceTypeExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<InterfaceTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes	`readonly InterfaceTypeExtensionNode[]`	AST extension nodes applied to this schema element.

getFields()

Returns the fields defined by this type.

Signature:

getFields(): GraphQLFieldMap<any, any>;

Returns

Type	Description
`GraphQLFieldMap<any, any>`	The fields keyed by field name.

Example

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!'

getInterfaces()

Returns the interfaces implemented by this type.

Signature:

getInterfaces(): readonly GraphQLInterfaceType[];

Returns

Type	Description
`readonly GraphQLInterfaceType[]`	The implemented interfaces.

Example

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']

toConfig()

Returns a normalized configuration object for this object.

Signature:

toConfig(): GraphQLInterfaceTypeNormalizedConfig;

Returns

Type	Description
`GraphQLInterfaceTypeNormalizedConfig`	A configuration object that can be used to recreate this object.

Example

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!'

toString()

Returns the schema coordinate identifying this interface type.

Signature:

toString(): string;

Returns

Type	Description
`string`	The schema coordinate for this interface type.

Example

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'

toJSON()

Returns the JSON representation used when this object is serialized.

Signature:

toJSON(): string;

Returns

Type	Description
`string`	The JSON-serializable representation.

Example

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"}'

GraphQLUnionType

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

const PetType = new GraphQLUnionType({
  name: 'Pet',
  types: [DogType, CatType],
  resolveType: (value) => {
    if (value instanceof Dog) {
      return DogType;
    }
    if (value instanceof Cat) {
      return CatType;
    }
  }
});

Constructor

Creates a GraphQLUnionType instance.

Signature:

new GraphQLUnionType(
  config: Readonly<GraphQLUnionTypeConfig<any, any>>,
);

Arguments

Name	Type	Description
config	`Readonly<GraphQLUnionTypeConfig<any, any>>`	Configuration describing this object.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
resolveType	`Maybe<GraphQLTypeResolver<any, any>>`	Function that resolves the concrete object type for this abstract type.
extensions	`Readonly<GraphQLUnionTypeExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<UnionTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes	`readonly UnionTypeExtensionNode[]`	AST extension nodes applied to this schema element.

getTypes()

Returns the object types included in this union.

Signature:

getTypes(): readonly GraphQLObjectType[];

Returns

Type	Description
`readonly GraphQLObjectType[]`	The union member object types.

Example

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']

toConfig()

Returns a normalized configuration object for this object.

Signature:

toConfig(): {
  types: ReadonlyArray<GraphQLObjectType>;
  extensions: Readonly<GraphQLUnionTypeExtensions>;
  extensionASTNodes: ReadonlyArray<UnionTypeExtensionNode>;
};

Returns

Type	Description
`{ types: ReadonlyArray<GraphQLObjectType>; extensions: Readonly<GraphQLUnionTypeExtensions>; extensionASTNodes: ReadonlyArray<UnionTypeExtensionNode>; }`	A configuration object that can be used to recreate this object.

Example

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']

toString()

Returns the schema coordinate identifying this union type.

Signature:

toString(): string;

Returns

Type	Description
`string`	The schema coordinate for this union type.

Example

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'

toJSON()

Returns the JSON representation used when this object is serialized.

Signature:

toJSON(): string;

Returns

Type	Description
`string`	The JSON-serializable representation.

Example

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"}'

GraphQLEnumType

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

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

Creates a GraphQLEnumType instance.

Signature:

new GraphQLEnumType(config: Readonly<GraphQLEnumTypeConfig>);

Arguments

Name	Type	Description
config	`Readonly<GraphQLEnumTypeConfig>`	Configuration describing this object.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
extensions	`Readonly<GraphQLEnumTypeExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<EnumTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes	`readonly EnumTypeExtensionNode[]`	AST extension nodes applied to this schema element.

getValues()

Returns the values defined by this enum type.

Signature:

getValues(): readonly GraphQLEnumValue[];

Returns

Type	Description
`readonly GraphQLEnumValue[]`	Enum value definitions in schema order.

Example

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']

getValue()

Returns the enum value definition for a value name.

Signature:

getValue(
  name: string,
): Maybe<GraphQLEnumValue>;

Arguments

Name	Type	Description
name	`string`	The GraphQL name to look up.

Returns

Type	Description
`Maybe<GraphQLEnumValue>`	The matching enum value definition, if it exists.

Example

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

serialize()

Serializes a runtime enum value as a GraphQL enum name.

Signature:

serialize(
  outputValue: unknown,
): Maybe<string>;

Arguments

Name	Type	Description
outputValue	`unknown`	Runtime enum value to serialize.

Returns

Type	Description
`Maybe<string>`	The GraphQL enum name for the runtime value.

Example

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

parseValue()

Parses a GraphQL enum name from variable input.

Signature:

parseValue(inputValue: unknown): any;

Arguments

Name	Type	Description
inputValue	`unknown`	Runtime input value to parse.

Returns

Type	Description
`any`	The internal enum value represented by the input name.

Example

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'); // throws an error
RGB.parseValue(2); // throws an error

parseLiteral()

Parses a GraphQL enum name from an AST value literal.

Signature:

parseLiteral(
  valueNode: ValueNode,
  _variables: Maybe<ObjMap<unknown>>,
): any;

Arguments

Name	Type	Description
valueNode	`ValueNode`	AST value literal to parse.
_variables	`Maybe<ObjMap<unknown>>`	Runtime variable values; ignored because enum literals cannot contain variables.

Returns

Type	Description
`any`	The internal enum value represented by the literal.

Example

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

toConfig()

Returns a normalized configuration object for this object.

Signature:

toConfig(): {
  values: ObjMap<GraphQLEnumValueConfig>;
  extensions: Readonly<GraphQLEnumTypeExtensions>;
  extensionASTNodes: ReadonlyArray<EnumTypeExtensionNode>;
};

Returns

Type	Description
`{ values: ObjMap<GraphQLEnumValueConfig>; extensions: Readonly<GraphQLEnumTypeExtensions>; extensionASTNodes: ReadonlyArray<EnumTypeExtensionNode>; }`	A configuration object that can be used to recreate this object.

Example

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.serialize(2); // => 'BLUE'

toString()

Returns the schema coordinate identifying this enum type.

Signature:

toString(): string;

Returns

Type	Description
`string`	The schema coordinate for this enum type.

Example

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'

toJSON()

Returns the JSON representation used when this object is serialized.

Signature:

toJSON(): string;

Returns

Type	Description
`string`	The JSON-serializable representation.

Example

import { GraphQLEnumType } from 'graphql/type';
 
const Episode = new GraphQLEnumType({
  name: 'Episode',
  values: {
    NEW_HOPE: {},
  },
});
 
Episode.toJSON(); // => 'Episode'
JSON.stringify({ type: Episode }); // => '{"type":"Episode"}'

GraphQLInputObjectType

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

const GeoPoint = new GraphQLInputObjectType({
  name: 'GeoPoint',
  fields: {
    lat: { type: new GraphQLNonNull(GraphQLFloat) },
    lon: { type: new GraphQLNonNull(GraphQLFloat) },
    alt: { type: GraphQLFloat, defaultValue: 0 },
  }
});

Constructor

Creates a GraphQLInputObjectType instance.

Signature:

new GraphQLInputObjectType(config: Readonly<GraphQLInputObjectTypeConfig>);

Arguments

Name	Type	Description
config	`Readonly<GraphQLInputObjectTypeConfig>`	Configuration describing this object.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
extensions	`Readonly<GraphQLInputObjectTypeExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<InputObjectTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes	`readonly InputObjectTypeExtensionNode[]`	AST extension nodes applied to this schema element.
isOneOf	`boolean`	Whether this input object uses the experimental OneOf input object semantics.

getFields()

Returns the fields defined by this type.

Signature:

getFields(): GraphQLInputFieldMap;

Returns

Type	Description
`GraphQLInputFieldMap`	The fields keyed by field name.

Example

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.defaultValue; // => ''

toConfig()

Returns a normalized configuration object for this object.

Signature:

toConfig(): {
  fields: GraphQLInputFieldConfigMap;
  extensions: Readonly<GraphQLInputObjectTypeExtensions>;
  extensionASTNodes: ReadonlyArray<InputObjectTypeExtensionNode>;
};

Returns

Type	Description
`{ fields: GraphQLInputFieldConfigMap; extensions: Readonly<GraphQLInputObjectTypeExtensions>; extensionASTNodes: ReadonlyArray<InputObjectTypeExtensionNode>; }`	A configuration object that can be used to recreate this object.

Example

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!'

toString()

Returns the schema coordinate identifying this input object type.

Signature:

toString(): string;

Returns

Type	Description
`string`	The schema coordinate for this input object type.

Example

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'

toJSON()

Returns the JSON representation used when this object is serialized.

Signature:

toJSON(): string;

Returns

Type	Description
`string`	The JSON-serializable representation.

Example

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"}'

Functions

isType()

Returns true when the value is any GraphQL type.

Signature:

isType(
  type: unknown,
): type is GraphQLType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLType`	True when the value is any GraphQL type.

Example

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

assertType()

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

Signature:

assertType(type: unknown): GraphQLType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLType`	The value typed as a GraphQL type.

Example

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

isScalarType()

There are predicates for each kind of GraphQL type.

Signature:

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

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLScalarType<unknown, unknown>`	True when the value is a GraphQLScalarType.

Example

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

assertScalarType()

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

Signature:

assertScalarType(type: unknown): GraphQLScalarType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLScalarType`	The value typed as a GraphQLScalarType.

Example

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

isObjectType()

Returns true when the value is a GraphQLObjectType.

Signature:

isObjectType(
  type: unknown,
): type is GraphQLObjectType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLObjectType`	True when the value is a GraphQLObjectType.

Example

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

assertObjectType()

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

Signature:

assertObjectType(type: unknown): GraphQLObjectType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLObjectType`	The value typed as a GraphQLObjectType.

Example

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

isInterfaceType()

Returns true when the value is a GraphQLInterfaceType.

Signature:

isInterfaceType(
  type: unknown,
): type is GraphQLInterfaceType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLInterfaceType`	True when the value is a GraphQLInterfaceType.

Example

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

assertInterfaceType()

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

Signature:

assertInterfaceType(type: unknown): GraphQLInterfaceType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLInterfaceType`	The value typed as a GraphQLInterfaceType.

Example

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

isUnionType()

Returns true when the value is a GraphQLUnionType.

Signature:

isUnionType(
  type: unknown,
): type is GraphQLUnionType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLUnionType`	True when the value is a GraphQLUnionType.

Example

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

assertUnionType()

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

Signature:

assertUnionType(type: unknown): GraphQLUnionType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLUnionType`	The value typed as a GraphQLUnionType.

Example

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

isEnumType()

Returns true when the value is a GraphQLEnumType.

Signature:

isEnumType(
  type: unknown,
): type is GraphQLEnumType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLEnumType`	True when the value is a GraphQLEnumType.

Example

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

assertEnumType()

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

Signature:

assertEnumType(type: unknown): GraphQLEnumType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLEnumType`	The value typed as a GraphQLEnumType.

Example

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

isInputObjectType()

Returns true when the value is a GraphQLInputObjectType.

Signature:

isInputObjectType(
  type: unknown,
): type is GraphQLInputObjectType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLInputObjectType`	True when the value is a GraphQLInputObjectType.

Example

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

assertInputObjectType()

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

Signature:

assertInputObjectType(type: unknown): GraphQLInputObjectType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLInputObjectType`	The value typed as a GraphQLInputObjectType.

Example

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

isListType()

Overload 1

Returns true when the value is a GraphQLList.

Signature:

isListType(
  type: GraphQLInputType,
): type is GraphQLList<GraphQLInputType>;

Arguments

Name	Type	Description
type	`GraphQLInputType`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLList<GraphQLInputType>`	True when the value is a GraphQLList.

Example

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

Overload 2

Returns true when the output type is a GraphQLList.

Signature:

isListType(
  type: GraphQLOutputType,
): type is GraphQLList<GraphQLOutputType>;

Arguments

Name	Type	Description
type	`GraphQLOutputType`	The GraphQL output type to inspect.

Returns

Type	Description
`type is GraphQLList<GraphQLOutputType>`	True when the output type is a list type.

Example

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

Overload 3

Returns true when the value is a GraphQLList.

Signature:

isListType(
  type: unknown,
): type is GraphQLList<GraphQLType>;

Arguments

Name	Type	Description
type	`unknown`	The value to inspect.

Returns

Type	Description
`type is GraphQLList<GraphQLType>`	True when the value is a list type.

Example

import { isListType } from 'graphql/type';
 
isListType('[String]'); // => false
isListType(null); // => false

assertListType()

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

Signature:

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

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLList<GraphQLType>`	The value typed as a GraphQLList.

Example

import { GraphQLList, GraphQLString, assertListType } from 'graphql/type';
 
const listType = assertListType(new GraphQLList(GraphQLString));
 
listType.ofType; // => GraphQLString
assertListType(GraphQLString); // throws an error

isNonNullType()

Overload 1

Returns true when the value is a GraphQLNonNull.

Signature:

isNonNullType(
  type: GraphQLInputType,
): type is GraphQLNonNull<GraphQLInputType>;

Arguments

Name	Type	Description
type	`GraphQLInputType`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLNonNull<GraphQLInputType>`	True when the value is a GraphQLNonNull.

Example

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

Overload 2

Returns true when the output type is a GraphQLNonNull.

Signature:

isNonNullType(
  type: GraphQLOutputType,
): type is GraphQLNonNull<GraphQLOutputType>;

Arguments

Name	Type	Description
type	`GraphQLOutputType`	The GraphQL output type to inspect.

Returns

Type	Description
`type is GraphQLNonNull<GraphQLOutputType>`	True when the output type is a non-null type.

Example

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

Overload 3

Returns true when the value is a GraphQLNonNull.

Signature:

isNonNullType(
  type: unknown,
): type is GraphQLNonNull<GraphQLType>;

Arguments

Name	Type	Description
type	`unknown`	The value to inspect.

Returns

Type	Description
`type is GraphQLNonNull<GraphQLType>`	True when the value is a non-null type.

Example

import { isNonNullType } from 'graphql/type';
 
isNonNullType('String!'); // => false
isNonNullType(null); // => false

assertNonNullType()

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

Signature:

assertNonNullType(
  type: unknown,
): GraphQLNonNull<GraphQLType>;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLNonNull<GraphQLType>`	The value typed as a GraphQLNonNull.

Example

import { GraphQLNonNull, GraphQLString, assertNonNullType } from 'graphql/type';
 
const nonNullType = assertNonNullType(new GraphQLNonNull(GraphQLString));
 
nonNullType.ofType; // => GraphQLString
assertNonNullType(GraphQLString); // throws an error

isInputType()

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

Signature:

isInputType(
  type: unknown,
): type is GraphQLInputType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLInputType`	True when the value can be used as a GraphQL input type.

Example

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

assertInputType()

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

Signature:

assertInputType(type: unknown): GraphQLInputType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLInputType`	The value typed as a GraphQL input type.

Example

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

isOutputType()

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

Signature:

isOutputType(
  type: unknown,
): type is GraphQLOutputType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLOutputType`	True when the value can be used as a GraphQL output type.

Example

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

assertOutputType()

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

Signature:

assertOutputType(type: unknown): GraphQLOutputType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLOutputType`	The value typed as a GraphQL output type.

Example

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

isLeafType()

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

Signature:

isLeafType(
  type: unknown,
): type is GraphQLLeafType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLLeafType`	True when the value is a GraphQL scalar or enum type.

Example

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

assertLeafType()

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

Signature:

assertLeafType(type: unknown): GraphQLLeafType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLLeafType`	The value typed as a GraphQL leaf type.

Example

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

isCompositeType()

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

Signature:

isCompositeType(
  type: unknown,
): type is GraphQLCompositeType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLCompositeType`	True when the value is a GraphQL object, interface, or union type.

Example

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

assertCompositeType()

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

Signature:

assertCompositeType(type: unknown): GraphQLCompositeType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLCompositeType`	The value typed as a GraphQL composite type.

Example

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

isAbstractType()

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

Signature:

isAbstractType(
  type: unknown,
): type is GraphQLAbstractType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLAbstractType`	True when the value is a GraphQL interface or union type.

Example

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

assertAbstractType()

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

Signature:

assertAbstractType(type: unknown): GraphQLAbstractType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLAbstractType`	The value typed as a GraphQL abstract type.

Example

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

isWrappingType()

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

Signature:

isWrappingType(
  type: unknown,
): type is GraphQLWrappingType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLWrappingType`	True when the value is a GraphQL list or non-null wrapper type.

Example

import {
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
  isWrappingType,
} from 'graphql/type';
 
isWrappingType(new GraphQLList(GraphQLString)); // => true
isWrappingType(new GraphQLNonNull(GraphQLString)); // => true
isWrappingType(GraphQLString); // => false

assertWrappingType()

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

Signature:

assertWrappingType(type: unknown): GraphQLWrappingType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLWrappingType`	The value typed as a GraphQL wrapping type.

Example

import { GraphQLList, GraphQLString, assertWrappingType } from 'graphql/type';
 
const wrappingType = assertWrappingType(new GraphQLList(GraphQLString));
 
wrappingType.toString(); // => '[String]'
assertWrappingType(GraphQLString); // throws an error

isNullableType()

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

Signature:

isNullableType(
  type: unknown,
): type is GraphQLNullableType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLNullableType`	True when the value is a GraphQL type that can accept null.

Example

import { GraphQLNonNull, GraphQLString, isNullableType } from 'graphql/type';
 
isNullableType(GraphQLString); // => true
isNullableType(new GraphQLNonNull(GraphQLString)); // => false
isNullableType(null); // => false

assertNullableType()

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

Signature:

assertNullableType(type: unknown): GraphQLNullableType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLNullableType`	The value typed as a nullable GraphQL type.

Example

import {
  GraphQLNonNull,
  GraphQLString,
  assertNullableType,
} from 'graphql/type';
 
const nullableType = assertNullableType(GraphQLString);
 
nullableType; // => GraphQLString
assertNullableType(new GraphQLNonNull(GraphQLString)); // throws an error

getNullableType()

Overload 1

Returns the nullable type.

Signature:

getNullableType(type: null | undefined): void;

Arguments

Name	Type	Description
type	`null \| undefined`	The GraphQL type to inspect.

Example

import { getNullableType } from 'graphql/type';
 
getNullableType(null); // => undefined
getNullableType(undefined); // => undefined

Overload 2

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

Type Parameters

Name	Constraint	Default	Description
T	`GraphQLNullableType`		The nullable GraphQL type returned after removing one non-null wrapper.

Signature:

getNullableType<T extends GraphQLNullableType>(
  type:
    | T
    | GraphQLNonNull<T>,
): T;

Arguments

Name	Type	Description
type	`T \| GraphQLNonNull<T>`	A nullable type or non-null wrapper.

Returns

Type	Description
`T`	The nullable type after removing one non-null wrapper, if present.

Example

import {
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
  getNullableType,
} from 'graphql/type';
 
const requiredString = new GraphQLNonNull(GraphQLString);
const stringList = new GraphQLList(GraphQLString);
 
getNullableType(requiredString); // => GraphQLString
getNullableType(stringList); // => stringList

Overload 3

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

Signature:

getNullableType(
  type: Maybe<GraphQLType>,
): GraphQLNullableType | undefined;

Arguments

Name	Type	Description
type	`Maybe<GraphQLType>`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLNullableType \| undefined`	The nullable type after removing one non-null wrapper, if present.

Example

import {
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
  getNullableType,
} from 'graphql/type';
 
const requiredStringList = new GraphQLNonNull(
  new GraphQLList(GraphQLString),
);
 
getNullableType(requiredStringList).toString(); // => '[String]'
getNullableType(GraphQLString); // => GraphQLString

isNamedType()

Returns true when the value is a GraphQL named type.

Signature:

isNamedType(
  type: unknown,
): type is GraphQLNamedType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`type is GraphQLNamedType`	True when the value is a GraphQL named type.

Example

import { GraphQLList, GraphQLString, isNamedType } from 'graphql/type';
 
isNamedType(GraphQLString); // => true
isNamedType(new GraphQLList(GraphQLString)); // => false
isNamedType(null); // => false

assertNamedType()

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

Signature:

assertNamedType(type: unknown): GraphQLNamedType;

Arguments

Name	Type	Description
type	`unknown`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLNamedType`	The value typed as a GraphQL named type.

Example

import { GraphQLList, GraphQLString, assertNamedType } from 'graphql/type';
 
const namedType = assertNamedType(GraphQLString);
 
namedType.name; // => 'String'
assertNamedType(new GraphQLList(GraphQLString)); // throws an error

getNamedType()

Overload 1

Returns the named type.

Signature:

getNamedType(type: null | undefined): void;

Arguments

Name	Type	Description
type	`null \| undefined`	The GraphQL type to inspect.

Example

import { getNamedType } from 'graphql/type';
 
getNamedType(null); // => undefined
getNamedType(undefined); // => undefined

Overload 2

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

Signature:

getNamedType(
  type: GraphQLInputType,
): GraphQLNamedInputType;

Arguments

Name	Type	Description
type	`GraphQLInputType`	The GraphQL input type to inspect.

Returns

Type	Description
`GraphQLNamedInputType`	The named input type after unwrapping all wrappers.

Example

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'

Overload 3

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

Signature:

getNamedType(
  type: GraphQLOutputType,
): GraphQLNamedOutputType;

Arguments

Name	Type	Description
type	`GraphQLOutputType`	The GraphQL output type to inspect.

Returns

Type	Description
`GraphQLNamedOutputType`	The named output type after unwrapping all wrappers.

Example

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'

Overload 4

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

Signature:

getNamedType(
  type: GraphQLType,
): GraphQLNamedType;

Arguments

Name	Type	Description
type	`GraphQLType`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLNamedType`	The named type after unwrapping all wrappers.

Example

import {
  GraphQLList,
  GraphQLNonNull,
  GraphQLString,
  getNamedType,
} from 'graphql/type';
 
const nestedType = new GraphQLNonNull(
  new GraphQLList(new GraphQLNonNull(GraphQLString)),
);
 
getNamedType(nestedType); // => GraphQLString

Overload 5

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

Signature:

getNamedType(
  type: Maybe<GraphQLType>,
): GraphQLNamedType | undefined;

Arguments

Name	Type	Description
type	`Maybe<GraphQLType>`	The GraphQL type to inspect.

Returns

Type	Description
`GraphQLNamedType \| undefined`	The named type after unwrapping all wrappers, or undefined for nullish input.

Example

import {
  GraphQLList,
  GraphQLString,
  getNamedType,
} from 'graphql/type';
 
getNamedType(new GraphQLList(GraphQLString)); // => GraphQLString
getNamedType(undefined); // => undefined

resolveReadonlyArrayThunk()

Resolves a thunked readonly array.

Type Parameters

Name	Constraint	Default	Description
T			The element type resolved from the thunk or array.

Signature:

resolveReadonlyArrayThunk<T>(
  thunk: ThunkReadonlyArray<T>,
): readonly T[];

Arguments

Name	Type	Description
thunk	`ThunkReadonlyArray<T>`	The thunk or value to resolve.

Returns

Type	Description
`readonly T[]`	The resolved readonly array.

Example

import { GraphQLString, resolveReadonlyArrayThunk } from 'graphql/type';
 
const lazyFields = resolveReadonlyArrayThunk(() => [GraphQLString]);
const fields = resolveReadonlyArrayThunk([GraphQLString]);
 
lazyFields; // => [GraphQLString]
fields; // => [GraphQLString]

resolveObjMapThunk()

Resolves a thunked object map.

Type Parameters

Name	Constraint	Default	Description
T			The object-map value type resolved from the thunk or map.

Signature:

resolveObjMapThunk<T>(
  thunk: ThunkObjMap<T>,
): ObjMap<T>;

Arguments

Name	Type	Description
thunk	`ThunkObjMap<T>`	The thunk or value to resolve.

Returns

Type	Description
`ObjMap<T>`	The resolved object map.

Example

import { GraphQLString, resolveObjMapThunk } from 'graphql/type';
 
const lazyFields = resolveObjMapThunk(() => ({ name: GraphQLString }));
const fields = resolveObjMapThunk({ name: GraphQLString });
 
lazyFields.name; // => GraphQLString
fields.name; // => GraphQLString

isRequiredArgument()

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

Signature:

isRequiredArgument(arg: GraphQLArgument): boolean;

Arguments

Name	Type	Description
arg	`GraphQLArgument`	The argument definition to inspect.

Returns

Type	Description
`boolean`	True when the argument is non-null and has no default value.

Example

import {
  GraphQLInt,
  GraphQLNonNull,
  GraphQLString,
  isRequiredArgument,
} from 'graphql/type';
 
const requiredArgument = { name: 'id', type: new GraphQLNonNull(GraphQLInt) };
const optionalArgument = { name: 'name', type: GraphQLString };
const argumentWithDefault = {
  name: 'limit',
  type: new GraphQLNonNull(GraphQLInt),
  defaultValue: 10,
};
 
isRequiredArgument(requiredArgument); // => true
isRequiredArgument(optionalArgument); // => false
isRequiredArgument(argumentWithDefault); // => false

isRequiredInputField()

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

Signature:

isRequiredInputField(field: GraphQLInputField): boolean;

Arguments

Name	Type	Description
field	`GraphQLInputField`	The input field definition to inspect.

Returns

Type	Description
`boolean`	True when the input field is non-null and has no default value.

Example

import {
  GraphQLInt,
  GraphQLNonNull,
  GraphQLString,
  isRequiredInputField,
} from 'graphql/type';
 
const requiredField = { name: 'id', type: new GraphQLNonNull(GraphQLInt) };
const optionalField = { name: 'name', type: GraphQLString };
const fieldWithDefault = {
  name: 'limit',
  type: new GraphQLNonNull(GraphQLInt),
  defaultValue: 10,
};
 
isRequiredInputField(requiredField); // => true
isRequiredInputField(optionalField); // => false
isRequiredInputField(fieldWithDefault); // => false

Types

GraphQLType

Type alias. These are all of the possible kinds of types.

type GraphQLType =
  | GraphQLScalarType
  | GraphQLObjectType
  | GraphQLInterfaceType
  | GraphQLUnionType
  | GraphQLEnumType
  | GraphQLInputObjectType
  | GraphQLList<GraphQLType>
  | GraphQLNonNull<
      | GraphQLScalarType
      | GraphQLObjectType
      | GraphQLInterfaceType
      | GraphQLUnionType
      | GraphQLEnumType
      | GraphQLInputObjectType
      | GraphQLList<GraphQLType>
    >;

GraphQLInputType

Type alias. These types may be used as input types for arguments and directives.

type GraphQLInputType =
  | GraphQLScalarType
  | GraphQLEnumType
  | GraphQLInputObjectType
  | GraphQLList<GraphQLInputType>
  | GraphQLNonNull<
      | GraphQLScalarType
      | GraphQLEnumType
      | GraphQLInputObjectType
      | GraphQLList<GraphQLInputType>
    >;

GraphQLOutputType

Type alias. These types may be used as output types as the result of fields.

type GraphQLOutputType =
  | GraphQLScalarType
  | GraphQLObjectType
  | GraphQLInterfaceType
  | GraphQLUnionType
  | GraphQLEnumType
  | GraphQLList<GraphQLOutputType>
  | GraphQLNonNull<
      | GraphQLScalarType
      | GraphQLObjectType
      | GraphQLInterfaceType
      | GraphQLUnionType
      | GraphQLEnumType
      | GraphQLList<GraphQLOutputType>
    >;

GraphQLLeafType

Type alias. These types may describe types which may be leaf values.

type GraphQLLeafType = GraphQLScalarType | GraphQLEnumType;

GraphQLCompositeType

Type alias. These types may describe the parent context of a selection set.

type GraphQLCompositeType =
  | GraphQLObjectType
  | GraphQLInterfaceType
  | GraphQLUnionType;

GraphQLAbstractType

Type alias. These types may describe the parent context of a selection set.

type GraphQLAbstractType = GraphQLInterfaceType | GraphQLUnionType;

GraphQLWrappingType

Type alias. These types wrap and modify other types

type GraphQLWrappingType =
  | GraphQLList<GraphQLType>
  | GraphQLNonNull<GraphQLType>;

GraphQLNullableType

Type alias. These types can all accept null as a value.

type GraphQLNullableType =
  | GraphQLScalarType
  | GraphQLObjectType
  | GraphQLInterfaceType
  | GraphQLUnionType
  | GraphQLEnumType
  | GraphQLInputObjectType
  | GraphQLList<GraphQLType>;

GraphQLNamedType

Type alias. These named types do not include modifiers like List or NonNull.

type GraphQLNamedType = GraphQLNamedInputType | GraphQLNamedOutputType;

GraphQLNamedInputType

Type alias. A named GraphQL type that can be used as an input type.

type GraphQLNamedInputType =
  | GraphQLScalarType
  | GraphQLEnumType
  | GraphQLInputObjectType;

GraphQLNamedOutputType

Type alias. A named GraphQL type that can be used as an output type.

type GraphQLNamedOutputType =
  | GraphQLScalarType
  | GraphQLObjectType
  | GraphQLInterfaceType
  | GraphQLUnionType
  | GraphQLEnumType;

ThunkReadonlyArray

Type alias. Used while defining GraphQL types to allow for circular references in otherwise immutable type definitions.

Type Parameters

Name	Constraint	Default	Description
T			The element type returned by the thunk or array.

type ThunkReadonlyArray<T> =
  | (() => ReadonlyArray<T>)
  | ReadonlyArray<T>;

ThunkObjMap

Type alias. A thunk that resolves to an object map.

Type Parameters

Name	Constraint	Default	Description
T			Value type stored in the object map.

type ThunkObjMap<T> =
  | (() => ObjMap<T>)
  | ObjMap<T>;

GraphQLScalarTypeExtensions

Interface. 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.

GraphQLScalarSerializer

Type alias. Serializes a runtime value as a scalar output value.

Type Parameters

Name	Constraint	Default	Description
TExternal			The serialized representation returned for GraphQL results.

type GraphQLScalarSerializer<TExternal> = (
  outputValue: unknown,
) => TExternal;

GraphQLScalarValueParser

Type alias. Parses a runtime input value as a scalar input value.

Type Parameters

Name	Constraint	Default	Description
TInternal			The internal runtime representation produced from variable input.

type GraphQLScalarValueParser<TInternal> = (
  inputValue: unknown,
) => TInternal;

GraphQLScalarLiteralParser

Type alias. Parses a GraphQL value literal as a scalar input value.

Type Parameters

Name	Constraint	Default	Description
TInternal			The internal runtime representation produced from literal input.

type GraphQLScalarLiteralParser<TInternal> = (
  valueNode: ValueNode,
  variables?: Maybe<ObjMap<unknown>>,
) => TInternal;

GraphQLScalarTypeConfig

Interface. Configuration used to construct a GraphQLScalarType.

Type Parameters

Name	Constraint	Default	Description
TInternal			The internal runtime representation accepted by this scalar.
TExternal			The serialized representation exposed in GraphQL results.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
specifiedByURL?	`Maybe<string>`	URL identifying the behavior specified for this custom scalar.
serialize?	`GraphQLScalarSerializer<TExternal>`	Serializes an internal value to include in a response.
parseValue?	`GraphQLScalarValueParser<TInternal>`	Parses an externally provided value to use as an input.
parseLiteral?	`GraphQLScalarLiteralParser<TInternal>`	Parses an externally provided literal value to use as an input.
extensions?	`Maybe<Readonly<GraphQLScalarTypeExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<ScalarTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes?	`Maybe<readonly ScalarTypeExtensionNode[]>`	AST extension nodes applied to this schema element.

GraphQLObjectTypeExtensions

Interface. Custom extensions

Type Parameters

Name	Constraint	Default	Description
_TSource		`any`	Reserved source type parameter for extension typing.
_TContext		`any`	Reserved context type parameter for extension typing.

GraphQLObjectTypeConfig

Interface. Configuration used to construct a GraphQLObjectType.

Type Parameters

Name	Constraint	Default	Description
TSource			Source object type passed to resolvers.
TContext			Context object type passed to resolvers.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
interfaces?	`ThunkReadonlyArray<GraphQLInterfaceType>`	Interfaces implemented by this object or interface type.
fields	`ThunkObjMap< GraphQLFieldConfig<TSource, TContext> >`	Fields declared by this object, interface, input object, or literal.
isTypeOf?	`Maybe< GraphQLIsTypeOfFn<TSource, TContext> >`	Predicate used to determine whether a runtime value belongs to this object type.
extensions?	`Maybe< Readonly< GraphQLObjectTypeExtensions<TSource, TContext> > >`	Extension fields to include in the formatted result.
astNode?	`Maybe<ObjectTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes?	`Maybe<readonly ObjectTypeExtensionNode[]>`	AST extension nodes applied to this schema element.

GraphQLTypeResolver

Type alias. Resolves the concrete object type for an abstract GraphQL type.

Type Parameters

Name	Constraint	Default	Description
TSource			Source object type passed to resolvers.
TContext			Context object type passed to resolvers.

type GraphQLTypeResolver<TSource, TContext> = (
  value: TSource,
  context: TContext,
  info: GraphQLResolveInfo,
  abstractType: GraphQLAbstractType,
) => PromiseOrValue<string | undefined>;

GraphQLIsTypeOfFn

Type alias. Checks whether a runtime value belongs to a GraphQL object type.

Type Parameters

Name	Constraint	Default	Description
TSource			Source object type tested against this object type.
TContext			Context object type passed to resolvers.

type GraphQLIsTypeOfFn<TSource, TContext> = (
  source: TSource,
  context: TContext,
  info: GraphQLResolveInfo,
) => PromiseOrValue<boolean>;

GraphQLFieldResolver

Type alias. Resolves the runtime value for a GraphQL field.

Type Parameters

Name	Default	Description
TSource		Source object type passed to resolvers.
TContext		Context object type passed to resolvers.
TArgs	`any`	Argument object type passed to resolvers.
TResult	`unknown`	Result value type.

type GraphQLFieldResolver<
  TSource,
  TContext,
  TArgs = any,
  TResult = unknown,
> = (
  source: TSource,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo,
) => TResult;

GraphQLResolveInfo

Interface. Information about the currently executing GraphQL field.

Members

Name	Type	Description
fieldName	`string`	The field name referenced by this schema coordinate.
fieldNodes	`readonly FieldNode[]`	AST field nodes that contributed to the current field execution.
returnType	`GraphQLOutputType`	GraphQL output type declared for the current field.
parentType	`GraphQLObjectType`	Object type that owns the current field.
path	`Path`	Response path where this error occurred during execution.
schema	`GraphQLSchema`	The schema used for validation or execution.
fragments	`ObjMap<FragmentDefinitionNode>`	Fragment definitions in the operation document keyed by fragment name.
rootValue	`unknown`	Initial root value passed to the operation.
operation	`OperationDefinitionNode`	The operation selected for execution.
variableValues	`{ [variable: string]: unknown }`	Runtime variable values keyed by variable name.

GraphQLFieldExtensions

Interface. Custom extensions

Type Parameters

Name	Default	Description
_TSource		Reserved source type parameter for extension typing.
_TContext		Reserved context type parameter for extension typing.
_TArgs	`any`	Reserved argument type parameter for extension typing.

GraphQLFieldConfig

Interface. Configuration used to define a GraphQL field.

Type Parameters

Name	Default	Description
TSource		Source object type passed to resolvers.
TContext		Context object type passed to resolvers.
TArgs	`any`	Argument object type passed to resolvers.

Members

Name	Type	Description
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
type	`GraphQLOutputType`	The GraphQL type reference or runtime type for this element.
args?	`GraphQLFieldConfigArgumentMap`	Arguments accepted by this field or directive.
resolve?	`GraphQLFieldResolver< TSource, TContext, TArgs >`	Resolver function used to produce this field value.
subscribe?	`GraphQLFieldResolver< TSource, TContext, TArgs >`	Resolver function used to create a subscription event stream for this field.
deprecationReason?	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions?	`Maybe< Readonly< GraphQLFieldExtensions< TSource, TContext, TArgs > > >`	Extension fields to include in the formatted result.
astNode?	`Maybe<FieldDefinitionNode>`	AST node from which this schema element was built, if available.

GraphQLFieldConfigArgumentMap

Type alias. A map of argument names to argument configuration objects.

type GraphQLFieldConfigArgumentMap = ObjMap<GraphQLArgumentConfig>;

GraphQLArgumentExtensions

Interface. Custom extensions

GraphQLArgumentConfig

Interface. Configuration used to define a GraphQL argument.

Members

Name	Type	Description
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
type	`GraphQLInputType`	The GraphQL type reference or runtime type for this element.
defaultValue?	`unknown`	Default value used when no explicit value is supplied.
deprecationReason?	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions?	`Maybe<Readonly<GraphQLArgumentExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<InputValueDefinitionNode>`	AST node from which this schema element was built, if available.

GraphQLFieldConfigMap

Type alias. A map of field names to field configuration objects.

Type Parameters

Name	Constraint	Default	Description
TSource			Source object type passed to resolvers.
TContext			Context object type passed to resolvers.

type GraphQLFieldConfigMap<TSource, TContext> =
  ObjMap<
    GraphQLFieldConfig<TSource, TContext>
  >;

GraphQLField

Interface. A resolved GraphQL field definition.

Type Parameters

Name	Default	Description
TSource		Source object type passed to resolvers.
TContext		Context object type passed to resolvers.
TArgs	`any`	Argument object type passed to resolvers.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
type	`GraphQLOutputType`	The GraphQL type reference or runtime type for this element.
args	`readonly GraphQLArgument[]`	Arguments accepted by this field or directive.
resolve?	`GraphQLFieldResolver< TSource, TContext, TArgs >`	Resolver function used to produce this field value.
subscribe?	`GraphQLFieldResolver< TSource, TContext, TArgs >`	Resolver function used to create a subscription event stream for this field.
deprecationReason	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions	`Readonly< GraphQLFieldExtensions< TSource, TContext, TArgs > >`	Extension fields to include in the formatted result.
astNode	`Maybe<FieldDefinitionNode>`	AST node from which this schema element was built, if available.

GraphQLArgument

Interface. A resolved GraphQL argument definition.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
type	`GraphQLInputType`	The GraphQL type reference or runtime type for this element.
defaultValue	`unknown`	Default value used when no explicit value is supplied.
deprecationReason	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions	`Readonly<GraphQLArgumentExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<InputValueDefinitionNode>`	AST node from which this schema element was built, if available.

GraphQLFieldMap

Type alias. A map of field names to resolved field definitions.

Type Parameters

Name	Constraint	Default	Description
TSource			Source object type passed to resolvers.
TContext			Context object type passed to resolvers.

type GraphQLFieldMap<TSource, TContext> =
  ObjMap<
    GraphQLField<TSource, TContext>
  >;

GraphQLInterfaceTypeExtensions

Interface. Custom extensions

GraphQLInterfaceTypeConfig

Interface. Configuration used to construct a GraphQLInterfaceType.

Type Parameters

Name	Constraint	Default	Description
TSource			Source object type passed to resolvers.
TContext			Context object type passed to resolvers.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
interfaces?	`ThunkReadonlyArray<GraphQLInterfaceType>`	Interfaces implemented by this object or interface type.
fields	`ThunkObjMap< GraphQLFieldConfig<TSource, TContext> >`	Fields declared by this object, interface, input object, or literal.
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.
extensions?	`Maybe<Readonly<GraphQLInterfaceTypeExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<InterfaceTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes?	`Maybe<readonly InterfaceTypeExtensionNode[]>`	AST extension nodes applied to this schema element.

GraphQLUnionTypeExtensions

Interface. Custom extensions

GraphQLUnionTypeConfig

Interface. Configuration used to construct a GraphQLUnionType.

Type Parameters

Name	Constraint	Default	Description
TSource			Source object type passed to resolvers.
TContext			Context object type passed to resolvers.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
types	`ThunkReadonlyArray<GraphQLObjectType>`	Object types that belong to this union type.
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.
extensions?	`Maybe<Readonly<GraphQLUnionTypeExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<UnionTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes?	`Maybe<readonly UnionTypeExtensionNode[]>`	AST extension nodes applied to this schema element.

GraphQLEnumTypeExtensions

Interface. Custom extensions

GraphQLEnumTypeConfig

Interface. Configuration used to construct a GraphQLEnumType.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
values	`ThunkObjMap<GraphQLEnumValueConfig>`	Values contained in this enum, list, or input-object definition.
extensions?	`Maybe<Readonly<GraphQLEnumTypeExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<EnumTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes?	`Maybe<readonly EnumTypeExtensionNode[]>`	AST extension nodes applied to this schema element.

GraphQLEnumValueConfigMap

Type alias. A map of enum value names to enum value configuration objects.

type GraphQLEnumValueConfigMap = ObjMap<GraphQLEnumValueConfig>;

GraphQLEnumValueExtensions

Interface. Custom extensions

GraphQLEnumValueConfig

Interface. Configuration used to define a GraphQL enum value.

Members

Name	Type	Description
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
value?	`any`	Parsed value represented by this node.
deprecationReason?	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions?	`Maybe<Readonly<GraphQLEnumValueExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<EnumValueDefinitionNode>`	AST node from which this schema element was built, if available.

GraphQLEnumValue

Interface. A resolved GraphQL enum value definition.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
value	`any`	Parsed value represented by this node.
deprecationReason	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions	`Readonly<GraphQLEnumValueExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<EnumValueDefinitionNode>`	AST node from which this schema element was built, if available.

GraphQLInputObjectTypeExtensions

Interface. Custom extensions

GraphQLInputObjectTypeConfig

Interface. Configuration used to construct a GraphQLInputObjectType.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
fields	`ThunkObjMap<GraphQLInputFieldConfig>`	Fields declared by this object, interface, input object, or literal.
extensions?	`Maybe<Readonly<GraphQLInputObjectTypeExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<InputObjectTypeDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes?	`Maybe<readonly InputObjectTypeExtensionNode[]>`	AST extension nodes applied to this schema element.
isOneOf?	`boolean`	Whether this input object uses the experimental OneOf input object semantics.

GraphQLInputFieldExtensions

Interface. Custom extensions

GraphQLInputFieldConfig

Interface. Configuration used to define a GraphQL input field.

Members

Name	Type	Description
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
type	`GraphQLInputType`	The GraphQL type reference or runtime type for this element.
defaultValue?	`unknown`	Default value used when no explicit value is supplied.
deprecationReason?	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions?	`Maybe<Readonly<GraphQLInputFieldExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<InputValueDefinitionNode>`	AST node from which this schema element was built, if available.

GraphQLInputFieldConfigMap

Type alias. A map of input field names to input field configuration objects.

type GraphQLInputFieldConfigMap = ObjMap<GraphQLInputFieldConfig>;

GraphQLInputField

Interface. A resolved GraphQL input field definition.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
type	`GraphQLInputType`	The GraphQL type reference or runtime type for this element.
defaultValue	`unknown`	Default value used when no explicit value is supplied.
deprecationReason	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions	`Readonly<GraphQLInputFieldExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<InputValueDefinitionNode>`	AST node from which this schema element was built, if available.

GraphQLInputFieldMap

Type alias. A map of input field names to resolved input field definitions.

type GraphQLInputFieldMap = ObjMap<GraphQLInputField>;

Category: Directives

Classes:
GraphQLDirective

Functions:
isDirective()assertDirective()isSpecifiedDirective()

Constants:
GraphQLIncludeDirective GraphQLSkipDirective DEFAULT_DEPRECATION_REASON GraphQLDeprecatedDirective GraphQLSpecifiedByDirective GraphQLOneOfDirective specifiedDirectives

Types:
GraphQLDirectiveExtensions GraphQLDirectiveConfig

Classes

GraphQLDirective

Directives are used by the GraphQL runtime as a way of modifying execution behavior. Type system creators will usually not create these directly.

Constructor

Creates a GraphQLDirective instance.

Signature:

new GraphQLDirective(config: Readonly<GraphQLDirectiveConfig>);

Arguments

Name	Type	Description
config	`Readonly<GraphQLDirectiveConfig>`	Configuration describing this object.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
locations	`readonly DirectiveLocation[]`	Locations where this directive may be applied.
args	`readonly GraphQLArgument[]`	Arguments accepted by this field or directive.
isRepeatable	`boolean`	Whether this directive may appear more than once at the same location.
deprecationReason	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions	`Readonly<GraphQLDirectiveExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<DirectiveDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes	`readonly DirectiveExtensionNode[]`	AST extension nodes applied to this schema element.

toConfig()

Returns a normalized configuration object for this object.

Signature:

toConfig(): {
  args: GraphQLFieldConfigArgumentMap;
  isRepeatable: boolean;
  extensions: Readonly<GraphQLDirectiveExtensions>;
  extensionASTNodes: ReadonlyArray<DirectiveExtensionNode>;
};

Returns

Type	Description
`{ args: GraphQLFieldConfigArgumentMap; isRepeatable: boolean; extensions: Readonly<GraphQLDirectiveExtensions>; extensionASTNodes: ReadonlyArray<DirectiveExtensionNode>; }`	A configuration object that can be used to recreate this object.

Example

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'

toString()

Returns the schema coordinate identifying this directive.

Signature:

toString(): string;

Returns

Type	Description
`string`	The directive schema coordinate.

Example

import { DirectiveLocation } from 'graphql/language';
import { GraphQLDirective } from 'graphql/type';
 
const tag = new GraphQLDirective({
  name: 'tag',
  locations: [DirectiveLocation.FIELD_DEFINITION],
});
 
tag.toString(); // => '@tag'

toJSON()

Returns the JSON representation used when this object is serialized.

Signature:

toJSON(): string;

Returns

Type	Description
`string`	The JSON-serializable representation.

Example

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"}'

Functions

isDirective()

Test if the given value is a GraphQL directive.

Signature:

isDirective(
  directive: unknown,
): directive is GraphQLDirective;

Arguments

Name	Type	Description
directive	`unknown`	Value to inspect.

Returns

Type	Description
`directive is GraphQLDirective`	True when the value is a GraphQLDirective.

Example

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

assertDirective()

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

Signature:

assertDirective(directive: unknown): GraphQLDirective;

Arguments

Name	Type	Description
directive	`unknown`	Value to inspect.

Returns

Type	Description
`GraphQLDirective`	The value typed as a GraphQLDirective.

Example

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

isSpecifiedDirective()

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

Signature:

isSpecifiedDirective(directive: GraphQLDirective): boolean;

Arguments

Name	Type	Description
directive	`GraphQLDirective`	Directive to inspect.

Returns

Type	Description
`boolean`	True when the directive is specified by GraphQL.

Example

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

Constants

GraphQLIncludeDirective

Used to conditionally include fields or fragments.

Type

GraphQLDirective

GraphQLSkipDirective

Used to conditionally skip (exclude) fields or fragments.

Type

GraphQLDirective

DEFAULT_DEPRECATION_REASON

Constant string used for default reason for a deprecation.

Type

'No longer supported'

GraphQLDeprecatedDirective

Used to declare element of a GraphQL schema as deprecated.

The optional reason argument defaults to DEFAULT_DEPRECATION_REASON.

Type

GraphQLDirective

GraphQLSpecifiedByDirective

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

Type

GraphQLDirective

GraphQLOneOfDirective

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

Type

GraphQLDirective

specifiedDirectives

Full list of stable directives specified by GraphQL.js.

Type

ReadonlyArray<GraphQLDirective>

Types

GraphQLDirectiveExtensions

Interface. Custom extensions

GraphQLDirectiveConfig

Interface. Configuration used to construct a GraphQLDirective.

Members

Name	Type	Description
name	`string`	The GraphQL name for this schema element.
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
locations	`readonly DirectiveLocation[]`	Locations where this directive may be applied.
args?	`Maybe<GraphQLFieldConfigArgumentMap>`	Arguments accepted by this field or directive.
isRepeatable?	`Maybe<boolean>`	Whether this directive may appear more than once at the same location.
deprecationReason?	`Maybe<string>`	Reason this element is deprecated, if one was provided.
extensions?	`Maybe<Readonly<GraphQLDirectiveExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<DirectiveDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes?	`Maybe<readonly DirectiveExtensionNode[]>`	AST extension nodes applied to this schema element.

Category: Introspection

Functions:
isIntrospectionType()

Constants:
__Schema __Directive __DirectiveLocation __Type __Field __InputValue __EnumValue __TypeKind SchemaMetaFieldDef TypeMetaFieldDef TypeNameMetaFieldDef introspectionTypes

Enumerations:
TypeKind

Functions

isIntrospectionType()

Returns true when the type is one of the built-in introspection types.

Signature:

isIntrospectionType(type: GraphQLNamedType): boolean;

Arguments

Name	Type	Description
type	`GraphQLNamedType`	The GraphQL type to inspect.

Returns

Type	Description
`boolean`	True when the type is one of the built-in introspection types.

Example

import { GraphQLString, isIntrospectionType, __Type } from 'graphql/type';
 
isIntrospectionType(__Type); // => true
isIntrospectionType(GraphQLString); // => false

ReadonlyArray<GraphQLNamedType>

Enumerations

TypeKind

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

Members

Name	Value	Description
`SCALAR`	`"SCALAR"`	A scalar type.
`OBJECT`	`"OBJECT"`	An object type.
`INTERFACE`	`"INTERFACE"`	An interface type.
`UNION`	`"UNION"`	A union type.
`ENUM`	`"ENUM"`	An enum type.
`INPUT_OBJECT`	`"INPUT_OBJECT"`	An input object type.
`LIST`	`"LIST"`	A list wrapper type.
`NON_NULL`	`"NON_NULL"`	A non-null wrapper type.

Category: Scalars

Functions:
isSpecifiedScalarType()

Constants:
GRAPHQL_MAX_INT GRAPHQL_MIN_INT GraphQLInt GraphQLFloat GraphQLString GraphQLBoolean GraphQLID specifiedScalarTypes

Functions

isSpecifiedScalarType()

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

Signature:

isSpecifiedScalarType(type: GraphQLNamedType): boolean;

Arguments

Name	Type	Description
type	`GraphQLNamedType`	The GraphQL type to inspect.

Returns

Type	Description
`boolean`	True when the scalar type is one of the scalars specified by GraphQL.

Example

import {
  GraphQLScalarType,
  GraphQLString,
  isSpecifiedScalarType,
} from 'graphql/type';
 
const DateTime = new GraphQLScalarType({
  name: 'DateTime',
});
 
isSpecifiedScalarType(GraphQLString); // => true
isSpecifiedScalarType(DateTime); // => false

ReadonlyArray<GraphQLScalarType>

Category: Schema

Classes:
GraphQLSchema

Functions:
isSchema()assertSchema()

Types:
GraphQLSchemaExtensions GraphQLSchemaConfig

Classes

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

Creates a GraphQLSchema instance.

Signature:

new GraphQLSchema(config: Readonly<GraphQLSchemaConfig>);

Arguments

Name	Type	Description
config	`Readonly<GraphQLSchemaConfig>`	Configuration describing this object.

Members

Name	Type	Description
description	`Maybe<string>`	Human-readable description for this schema element, if provided.
extensions	`Readonly<GraphQLSchemaExtensions>`	Extension fields to include in the formatted result.
astNode	`Maybe<SchemaDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes	`readonly SchemaExtensionNode[]`	AST extension nodes applied to this schema element.

getQueryType()

Returns the root object type for query operations.

Signature:

getQueryType(): Maybe<GraphQLObjectType>;

Returns

Type	Description
`Maybe<GraphQLObjectType>`	The query root type, if this schema defines one.

Example

import { buildSchema } from 'graphql/utilities';
 
const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
 
schema.getQueryType()?.name; // => 'Query'

getMutationType()

Returns the root object type for mutation operations.

Signature:

getMutationType(): Maybe<GraphQLObjectType>;

Returns

Type	Description
`Maybe<GraphQLObjectType>`	The mutation root type, if this schema defines one.

Example

import { buildSchema } from 'graphql/utilities';
 
const schema = buildSchema(`
  type Query {
    greeting: String
  }
 
  type Mutation {
    setGreeting(value: String!): String
  }
`);
 
schema.getMutationType()?.name; // => 'Mutation'

getSubscriptionType()

Returns the root object type for subscription operations.

Signature:

getSubscriptionType(): Maybe<GraphQLObjectType>;

Returns

Type	Description
`Maybe<GraphQLObjectType>`	The subscription root type, if this schema defines one.

Example

import { buildSchema } from 'graphql/utilities';
 
const schema = buildSchema(`
  type Query {
    greeting: String
  }
 
  type Subscription {
    greetings: String
  }
`);
 
schema.getSubscriptionType()?.name; // => 'Subscription'

getRootType()

Returns the root object type for the requested operation kind.

Signature:

getRootType(
  operation: OperationTypeNode,
): Maybe<GraphQLObjectType>;

Arguments

Name	Type	Description
operation	`OperationTypeNode`	Operation kind to resolve.

Returns

Type	Description
`Maybe<GraphQLObjectType>`	The root object type for the operation kind, if this schema defines one.

Example

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

getTypeMap()

Returns all named types known to this schema.

Signature:

getTypeMap(): ObjMap<GraphQLNamedType>;

Returns

Type	Description
`ObjMap<GraphQLNamedType>`	A map of schema types keyed by type name.

Example

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'

getType()

Returns the named type with the provided name.

Signature:

getType(
  name: string,
): GraphQLNamedType | undefined;

Arguments

Name	Type	Description
name	`string`	The GraphQL name to look up.

Returns

Type	Description
`GraphQLNamedType \| undefined`	The named schema type, if one exists.

Example

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

getPossibleTypes()

Returns object types that may be returned for an abstract type.

Signature:

getPossibleTypes(
  abstractType: GraphQLAbstractType,
): readonly GraphQLObjectType[];

Arguments

Name	Type	Description
abstractType	`GraphQLAbstractType`	Interface or union type to inspect.

Returns

Type	Description
`readonly GraphQLObjectType[]`	Object types that may satisfy the abstract type.

Example

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']

getImplementations()

Returns objects and interfaces that implement an interface type.

Signature:

getImplementations(interfaceType: GraphQLInterfaceType): {
  objects: readonly GraphQLObjectType[];
  interfaces: readonly GraphQLInterfaceType[];
};

Arguments

Name	Type	Description
interfaceType	`GraphQLInterfaceType`	Interface type to inspect.

Returns

Type	Description
`{ objects: readonly GraphQLObjectType[]; interfaces: readonly GraphQLInterfaceType[]; }`	Object and interface implementations of the interface.

Example

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']

isSubType()

Returns whether one type is a possible runtime subtype of an abstract type.

Signature:

isSubType(
  abstractType: GraphQLAbstractType,
  maybeSubType: GraphQLObjectType | GraphQLInterfaceType,
): boolean;

Arguments

Name	Type	Description
abstractType	`GraphQLAbstractType`	Interface or union type to inspect.
maybeSubType	`GraphQLObjectType \| GraphQLInterfaceType`	Object or interface type to test as a possible subtype.

Returns

Type	Description
`boolean`	True when the subtype may satisfy the abstract type.

Example

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

getDirectives()

Returns directives available in this schema.

Signature:

getDirectives(): readonly GraphQLDirective[];

Returns

Type	Description
`readonly GraphQLDirective[]`	Directives available in this schema.

Example

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']

getDirective()

Returns the current directive definition.

Signature:

getDirective(
  name: string,
): Maybe<GraphQLDirective>;

Arguments

Name	Type	Description
name	`string`	The GraphQL name to look up.

Returns

Type	Description
`Maybe<GraphQLDirective>`	The current directive definition, if known.

Example

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

toConfig()

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.

Signature:

toConfig(): GraphQLSchemaNormalizedConfig;

Returns

Type	Description
`GraphQLSchemaNormalizedConfig`	A configuration object that can be used to recreate this object.

Example

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'

Functions

isSchema()

Test if the given value is a GraphQL schema.

Signature:

isSchema(
  schema: unknown,
): schema is GraphQLSchema;

Arguments

Name	Type	Description
schema	`unknown`	Value to inspect.

Returns

Type	Description
`schema is GraphQLSchema`	True when the value is a GraphQLSchema.

Example

import { buildSchema } from 'graphql/utilities';
import { GraphQLString, isSchema } from 'graphql/type';
 
const schema = buildSchema(`
  type Query {
    greeting: String
  }
`);
 
isSchema(schema); // => true
isSchema(GraphQLString); // => false

assertSchema()

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

Signature:

assertSchema(schema: unknown): GraphQLSchema;

Arguments

Name	Type	Description
schema	`unknown`	GraphQL schema to use.

Returns

Type	Description
`GraphQLSchema`	The value typed as a GraphQLSchema.

Example

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

Types

GraphQLSchemaExtensions

Interface. Custom extensions

GraphQLSchemaConfig

Interface. Configuration used to construct a GraphQLSchema.

Members

Name	Type	Description
description?	`Maybe<string>`	Human-readable description for this schema element, if provided.
query?	`Maybe<GraphQLObjectType>`	Root object type for query operations.
mutation?	`Maybe<GraphQLObjectType>`	Root object type for mutation operations.
subscription?	`Maybe<GraphQLObjectType>`	Root object type for subscription operations.
types?	`Maybe<readonly GraphQLNamedType[]>`	Object types that belong to this union type.
directives?	`Maybe<readonly GraphQLDirective[]>`	Directives available in this schema or applied to this AST node.
extensions?	`Maybe<Readonly<GraphQLSchemaExtensions>>`	Extension fields to include in the formatted result.
astNode?	`Maybe<SchemaDefinitionNode>`	AST node from which this schema element was built, if available.
extensionASTNodes?	`Maybe<readonly SchemaExtensionNode[]>`	AST extension nodes applied to this schema element.

Category: Validation

Functions:
validateSchema()assertValidSchema()

Functions

validateSchema()

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.

Signature:

validateSchema(
  schema: GraphQLSchema,
): readonly GraphQLError[];

Arguments

Name	Type	Description
schema	`GraphQLSchema`	GraphQL schema to use.

Returns

Type	Description
`readonly GraphQLError[]`	Schema validation errors, or an empty array when the schema is valid.

Example

import { validateSchema } from 'graphql/type';
import { buildSchema } from 'graphql/utilities';
 
const schema = buildSchema(`
  type Query {
    name: String
  }
`);
const errors = validateSchema(schema);
 
errors; // => []

assertValidSchema()

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

Signature:

assertValidSchema(schema: GraphQLSchema): void;

Arguments

Name	Type	Description
schema	`GraphQLSchema`	GraphQL schema to use.

Example

import { assertValidSchema } from 'graphql/type';
import { buildSchema } from 'graphql/utilities';
 
const schema = buildSchema(`
  type Query {
    name: String
  }
`);
 
assertValidSchema(schema); // does not throw

graphql/subscription graphql/utilities