All Classes and Interfaces

Class
Description
This Exception indicates that the current execution should be aborted.
 
 
 
 
Util class which converts schemas and optionally queries into anonymized schemas and queries.
 
 
This persisted query support class supports the Apollo scheme where the persisted query id is in ExecutionInput.getExtensions().
 
 
 
 
 
 
Class to check whether a given directive argument value matches a given directive definition.
 
 
 
 
 
Adapts an Ast node to the general node from the util package
This can take graphql language AST and print it out as a string
These print nodes into output writers
This will produce signature and privacy safe query documents that can be used for query categorisation and logging.
A class that helps you sort AST nodes
Allows for an easy way to "manipulate" the immutable Ast by changing specific nodes and getting back a new Ast containing the changed nodes while everything else is the same.
 
 
 
 
 
A modifier type that indicates the underlying data fetcher is run asynchronously
The standard graphql execution strategy that runs fields asynchronously non-blocking.
Async non-blocking execution, but serial: only one field at the time will be resolved.
 
This helper class will take a list of regular expressions and match them against the fully qualified name of a type and its fields.
 
 
 
A specific NodeLocation inside a node.
A reporter that captures all the difference events as they occur
This allows you to chain together a number of Instrumentation implementations and run them in sequence.
 
 
 
A reporter that chains together one or more difference reporters
This ensure that all fields have data fetchers and that unions and interfaces have type resolvers
Holds coerced variables, that is their values are now in a canonical form.
The Coercing interface is used by GraphQLScalarTypes to parse and serialize object values.
 
 
 
 
 
 
 
This combines a number of WiringFactorys together to act as one.
A single-line comment.
Contains methods for extracting Comment in various positions within and around Nodes
A reactive Publisher that bridges over another Publisher of `D` and maps the results to type `U` via a CompletionStage, handling errors in that stage
This callback interface allows custom implementations to decide if a field is included in a query or not.
The parameters given to a ConditionalNodeDecision
 
This represents a connection in Relay, which is a list of edges as well as a pageInfo that describes the pagination of that list.
Represents a connection cursor in Relay which is an opaque string that the server understands.
A data fetcher is responsible for returning a data value back for a given graphql field.
This is called when an exception is thrown during DataFetcher.get(DataFetchingEnvironment) execution
The parameters available to DataFetcherExceptionHandlers
 
The result object for DataFetcherExceptionHandlers
 
A helper for DataFetcherFactory
A DataFetcherFactory allows a level of indirection in providing DataFetchers for graphql fields.
This is passed to a DataFetcherFactory when it is invoked to get a DataFetcher
 
An object that can be returned from a DataFetcher that contains both data, local context and errors to be added to the final result.
 
A DataFetchingEnvironment instance of passed to a DataFetcher as a execution context and its the place where you can find out information to help you resolve a data value given a graphql field input
 
 
This class allows you to retrieve the selection set of fields that have been asked for when the DataFetcher was invoked.
 
 
This graphql Instrumentation will dispatch all the contained DataLoaders when each level of the graphql query is executed.
The options that control the operation of DataLoaderDispatcherInstrumentation
A base class that keeps track of whether aggressive batching can be used
A default implementation of Connection
 
 
 
The default field visibility of graphql-java is that everything is visible
Associates a Comparator with a GraphqlTypeComparatorEnvironment to control the scope in which the Comparator can be applied.
 
 
 
 
Public API because it should be used as a delegate when implementing a custom ValueUnboxer
 
DelegatingDataFetchingEnvironment implements DataFetchingEnvironment by delegating to an underlying instance.
A simple subscription that delegates to another
Helper to track deprecation Please use ISO-8601 format i.e.
Represents a node that can contain a description.
 
A classification of difference events.
 
This is called with each different encountered (including info ones) by a SchemaDiff operation
This represents the events that the SchemaDiff outputs.
 
This is an algorithm calculating the optimal edit to change the source graph into the target graph.
 
An optimal edit from one graph to another.
This is the level of difference between graphql APIs
Deprecated.
 
 
 
 
 
 
 
Info on all the directives provided by graphql specification
 
 
 
 
The directives that are understood by graphql-java
Represents a language node that can contain Directives.
This turns AST directives into runtime directives with resolved types and so on
 
A holder class that breaks a list of directives into maps to be more easily accessible in using classes
 
 
 
 
 
 
 
A wiring factory that will echo back the objects defined.
Represents an edge in Relay which is essentially a node of data T and the cursor for that node.
 
An edit operation between two graphs can be one of six types: insert vertex, delete vertex, change vertex, insert edge, delete edge, change edge
 
 
Higher level GraphQL semantic assigned to
 
 
 
 
 
 
 
 
 
 
Provides the Java runtime value for each graphql Enum value.
Errors in graphql-java can have a classification to help with the processing of errors.
All the errors in graphql belong to one of these categories
 
This graphql error will be used if a runtime exception is encountered while a data fetcher is invoked
 
An ExecutableNormalizedField represents a field in an executable graphql operation.
 
A ExecutableNormalizedOperation represent how the text of a graphql operation (sometimes known colloquially as a query) will be executed at runtime according to the graphql specification.
This factory can create a ExecutableNormalizedOperation which represents what would be executed during a given graphql operation.
 
 
 
 
 
This class can take a list of ExecutableNormalizedFields and compiling out a normalised operation Document that would represent how those fields maybe executed.
The result is a Document and a map of variables that would go with that document.
 
 
 
This opaque identifier is used to identify a unique query execution
A provider of ExecutionIds
This represents the series of values that can be input on a graphql query execution
 
This simple value class represents the result of performing a graphql query.
 
 
 
As the graphql query executes, it forms a hierarchy from parent fields (and their type) to their child fields (and their type) until a scalar type is encountered; this class captures that execution type information.
 
 
An execution strategy is give a list of fields from the graphql query to execute and find values for using a recursive strategy.
 
The parameters that are passed to execution strategies
 
This instrumentation can be used to control on what thread calls to DataFetchers happen on.
This describes what action is currently being done.
 
This represents code that the graphql-java project considers experimental API and while our intention is that it will progress to be PublicApi, its existence, signature of behavior may change between releases.
 
This class can be used to help build the graphql `extensions` map.
This interface is a callback asking code to merge two maps with an eye to creating the graphql `extensions` value.
Note: This is returned by InstrumentationFieldCompleteParameters.getFetchedValue() and therefore part of the public despite never used in a method signature.
 
 
 
This represents a field and its arguments that may be validated.
A field collector can iterate over field selection sets and build out the sub fields that have been selected, expanding named and inline fragments as it goes.s
 
 
 
Internal because FieldCollector is internal.
 
Used to calculate the complexity of a field.
 
A field in graphql is uniquely located within a parent type and hence code elements like DataFetcher need to be specified using those coordinates.
 
 
This approach uses field level tracking to achieve its aims of making the data loader more efficient
 
 
This pluggable interface allows you to validate the fields and their argument inputs before query execution.
This contains all of the field and their arguments for a given query.
This Instrumentation allows you to validate the fields of the query before the query is executed.
 
 
 
 
 
 
 
Transforms a schema by applying a visibility predicate to every field.
 
 
 
 
 
 
 
 
 
Provided to the DataFetcher, therefore public API
 
 
 
 
This Instrumentation ensure that a submitted introspection query is done in good faith.
 
This class is where all graphql-java query execution begins.
 
 
An applied directive represents the instance of a directive that is applied to a schema element, as opposed to it definition
 
This represents the argument values that can be placed on an GraphQLAppliedDirective.
 
This defines an argument that can be supplied to a graphql field (via GraphQLFieldDefinition.
 
This class provides an empty implementation of GraphqlListener, which can be extended to create a listener which only needs to handle a subset of the available methods.
The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
The GraphQLCodeRegistry holds that execution code that is associated with graphql types, namely the DataFetchers associated with fields, the TypeResolvers associated with abstract types and the GraphqlFieldVisibility
 
 
This context object can be used to contain key values that can be useful as "context" when executing DataFetchers
 
A directive can be used to modify the behavior of a graphql field or type.
 
Represents a graphql runtime type that can have GraphQLAppliedDirectives.
 
This represents a hierarchy an graphql runtime element upwards to its associated parent elements.
A graphql enumeration type has a limited set of values.
 
A graphql enumeration type has a limited set of values and this defines one of those unique values
 
The interface describing graphql errors NOTE: This class implements Serializable and hence it can be serialised and placed into a distributed cache.
A builder of GraphQLErrors
This helps you build GraphQLErrors and also has a quick way to make a DataFetcherResults from that error.
 
A base class for graphql runtime exceptions that also implement GraphQLError and can be used in a general sense direct or have specialisations made of it.
 
A trait like base class that contains the properties that GraphqlErrorException handles and can be used by other classes to derive their own builders.
This little helper allows GraphQlErrors to implement common things (hashcode/ equals ) and to specification more easily
 
Fields are the ways you get data values in graphql and a field definition represents a field, its type, the arguments it takes and the DataFetcher used to get data values for that field.
 
Types that can contain output fields are marked with this interface
This allows you to control the visibility of graphql fields.
The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
A GraphQLType which can implement interfaces
Types that can contain input fields are marked with this interface
Input objects defined via GraphQLInputObjectType contains these input fields.
 
graphql clearly delineates between the types of objects that represent the output of a query and input objects that can be fed into a graphql mutation.
 
A schema element that is concerned with input.
Input types represent those set of types that are allowed to be accepted as graphql mutation input, as opposed to GraphQLOutputTypes which can only be used as graphql response output.
Named schema elements that contain input type information.
The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
In graphql, an interface is an abstract type that defines the set of fields that a type must include to implement that interface.
 
 
A modified type that indicates there is a list of the underlying wrapped type, eg a list of strings or a list of booleans.
This interface defines a complete listener for a parse tree produced by GraphqlParser.
A modified type wraps another graphql type and modifies it behavior
Input types represent those set of types that are allowed to be accepted as graphql mutation input, as opposed to GraphQLOutputTypes which can only be used as graphql response output.
Output types represent those set of types that are allowed to be sent back as a graphql response, as opposed to GraphQLInputTypes which can only be used as graphql mutation input.
A Schema element which has a name and also a description and AST Node which it is based on.
A GraphQLType which is also a named element, which means it has a getName() method.
A modified type that indicates there the underlying wrapped type will not be null.
 
This is the work horse type and represents an object with one or more field values that can be retrieved by the graphql system.
 
Output types represent those set of types that are allowed to be sent back as a graphql response, as opposed to GraphQLInputTypes which can only be used as graphql mutation input.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A scalar type is a leaf node in the graphql tree of types.
 
The schema represents the combined type system of the graphql engine.
 
 
A GraphQLSchema can be viewed as a graph of GraphQLSchemaElement.
 
This indicates what traversal control to apply during the visitation and can be created via calls to methods like GraphQLSchemaVisitorEnvironment.ok() or GraphQLSchemaVisitorEnvironment.changeNode(GraphQLSchemaElement) say
 
This visitor interface offers more "smarts" above GraphQLTypeVisitor and aims to be easier to use with more type safe helpers.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
The deprecated methods still have implementations in case code outside graphql-java is calling them but internally the call paths have been replaced.
A type inside the GraphQLSchema.
 
 
Defines the scope to control where the registered Comparator can be applied.
 
 
 
A special type to allow a object/interface types to reference itself.
 
 
A utility class that helps work with GraphQLTypes
GraphQLTypeVisitor can be used to visit all the elements of a schema (types, fields, directives and so on) in a visitor pattern.
Base implementation of GraphQLTypeVisitor for convenience.
A union type is a polymorphic type that dynamically represents one of more concrete object types.
 
 
An implementation of the Hungarian algorithm for solving the assignment problem.
 
This enum is a type safe way to control what resource bundle to load from
A class that represents the intention to create a I18n message
Graphql syntax has a series of characters, such as spaces, new lines and commas that are not considered relevant to the syntax.
 
Graphql syntax has a series of characters, such as spaces, new lines and commas that are not considered relevant to the syntax.
 
 
The standard ImmutableMap does not allow null values.
A TypeDefinition that might implement interfaces
A support class to help break up the large SchemaTypeChecker class.
 
 
A PersistedQueryCache that is just an in memory map of known queries.
 
Schema validation rule ensuring no input type forms an unbroken non-nullable recursion, as such a type would be impossible to satisfy
This INTERNAL class can be used to intercept input values before they are coerced into runtime values by the ValuesResolver code.
https://facebook.github.io/graphql/#sec-Input-Objects - This unordered map should not contain any entries with names not defined by a field of this input object type, otherwise an error should be thrown.
 
 
 
 
 
 
Used by @GraphQLArgument and GraphQLInputObjectField to represent different value states.
 
Provides the capability to instrument the execution steps of a GraphQL query.
When a Instrumentation.'beginXXX()' method is called then it must return a non null InstrumentationContext that will be invoked when the step is first dispatched and then when it completes.
Parameters sent to Instrumentation methods
Parameters sent to Instrumentation methods
Parameters sent to Instrumentation methods
Parameters sent to Instrumentation methods
Parameters sent to Instrumentation methods
Parameters sent to Instrumentation methods
Parameters sent to Instrumentation methods
An Instrumentation implementation can create this as a stateful object that is then passed to each instrumentation method, allowing state to be passed down with the request execution
Parameters sent to Instrumentation methods
 
 
 
 
 
 
 
 
 
 
 
This represents code that the graphql-java project considers internal code that MAY not be stable within major releases.
This memoizing supplier DOES use locked double locking to set its value.
This memoizing supplier does NOT use synchronised double locking to set its value so on multiple threads it MAY call the delegate again to get a value.
GraphQl has a unique capability called Introspection that allow consumers to inspect the system and discover the fields and types available and makes the system self documented.
 
 
Special DataFetcher which is only used inside Introspection
Extracted from DataFetchingEnvironment to only capture the data really needed for Introspection
 
 
IntrospectionQueryBuilder allows you to build introspection queries controlled by the options you specify
 
 
The graphql specification does not allow you to retrieve the directives and their argument values that are present on types, enums, fields and input fields, so this class allows you to change the schema and enhance the Introspection types to contain this information.
A callback which allows you to decide what directives may be included in introspection extensions
The parameter environment on a call to IntrospectionWithDirectivesSupport.DirectivePredicate
 
 
 
 
 
 
This exception is thrown by the Parser if the graphql syntax is not valid
 
 
 
 
 
 
 
 
This data structure tracks the number of expected calls on a given level
A LightDataFetcher is a specialised version of DataFetcher that is passed more lightweight arguments when it is asked to fetch values.
 
 
This provides reentrant locking support for our code base.
Will allow for lazy computation of some values just once
A class to run code inside a reentrant lock
 
 
 
A mapping (in the math sense) from a list of vertices to another list of vertices.
Prevents execution if the query complexity is greater than the specified maxComplexity.
 
Prevents execution if the query depth is greater than the specified maxDepth.
This represents all Fields in a query which overlap and are merged into one.
 
 
 
 
 
 
This is thrown if a query is attempting to perform an operation not defined in the GraphQL schema
 
 
 
 
 
 
A delegating type visitor that allows you to call N visitors in a list and always continues via TraversalControl.CONTINUE
This reader allows you to read N number readers and combine them as one logical reader however you can then map back to the underlying readers in terms of their source name and the relative lines numbers.
 
 
 
This marks a type as mutable which means after constructing it can be changed.
This class is useful for creating a mutable reference to a variable that can be changed when you are in an effectively final bit of code.
Represents a language node that has a name
Simple EnumValuesProvided which maps the GraphQL Enum name to the Java Enum instance.
This version of ChainedInstrumentation will call a list of Instrumentations but it will never back on the returned InstrumentationContext objects, hence it is only suitable to certain use cases.
The base interface for virtually all graphql language elements NOTE: This class implements Serializable and hence it can be serialised and placed into a distributed cache.
Adapts an arbitrary class to behave as a node.
 
Container of children of a Node.
 
 
General position of a Node inside a parent.
 
This represents a hierarchy from a graphql language node upwards to its associated parent nodes.
A parser that will capture parsing context data which can be later used for accessing tokens that are discarded during the conventional parsing process (like comments).
 
Lets you traverse a Node tree.
Helper class for working with Nodes
 
Used by NodeTraverser to visit Node.
Convenient implementation of NodeVisitor for easy subclassing methods handling different types of Nodes in one method.
Internally used node visitor which delegates to a QueryVisitor with type information about the visited field.
 
 
 
Deprecated.
This is no longer the best way to prevent Introspection - Introspection.enabledJvmWide(boolean) can be used instead
Executor that provides mutual exclusion between the operations submitted to it, without blocking.
 
This will check that a value is non-null when the type definition says it must be and, it will throw NonNullableFieldWasNullException if this is not the case.
This is the base error that indicates that a non null field value was in fact null.
See (https://spec.graphql.org/October2021/#sec-Errors-and-Non-Nullability), but if a non nullable field actually resolves to a null value and the parent type is nullable then the parent must in fact become null so we use exceptions to indicate this special case
This is thrown if a non nullable value is coerced to a null value
 
 
 
 
 
 
 
 
An argument value with type information.
 
 
Schema validation rule ensuring no input type forms an unbroken non-nullable recursion, as such a type would be impossible to satisfy
 
 
 
 
 
 
 
 
 
 
 
 
 
 
The input map to One Of Input Types MUST only have 1 entry with a non null value
The input map to One Of Input Types MUST only have 1 entry
 
 
 
 
 
 
 
 
 
 
Represents pagination information in Relay about edges when used inside a connection See https://facebook.github.io/relay/graphql/connections.htm#sec-undefined.PageInfo
 
This class allows you to parse and validate a graphql query without executing it.
A result object used in ParseAndValidate helper that indicates the outcomes of a parse and validate operation.
 
 
 
 
This can parse graphql syntax, both Query syntax and Schema Definition Language (SDL) syntax, into an Abstract Syntax Tree (AST) represented by a Document
This is the arguments that can be passed to a Parser
 
Options that control how the Parser behaves.
 
This listener interface is invoked for each token parsed by the graphql parser code.
This represents a token that has been parsed
This interface is used to abstract an actual cache that can cache parsed persistent queries.
The call back when a valid persisted query is not in cache and it needs to be compiled and validated by the graphql engine.
 
 
An exception that indicates the query id is not valid and can be found ever in cache
This abstract class forms the basis for persistent query support.
 
We don't want to allow arbitrary schema changes.
 
An instance of a preparsed document entry represents the result of a query parse and validation.
Interface that allows clients to hook in Document caching and/or the whitelisting of queries.
A printer that acts as a code formatter.
Contains options that modify how a document is printed.
 
 
A reporter that prints its output to a PrintStream
This is the default data fetcher used in graphql-java, and it will examine maps, records and POJO java beans for values that match the desired name, typically the field name, or it will use a provided function to obtain values.
This class is the guts of a property data fetcher and also used in AST code to turn in memory java objects into AST elements
A re-usable class that can fetch from POJOs
 
 
 
 
 
This represents code that the graphql-java project considers public API and has an imperative to be stable within major releases.
This represents code that the graphql-java project considers public SPI and has an imperative to be stable within major releases.
An applied directive represents the instance of a directive that is applied to a query element such as a field or fragment.
 
This represents the argument values that can be placed on an QueryAppliedDirective.
 
This can calculate the complexity of an operation using the specified FieldComplexityCalculator you pass into it.
 
The query complexity info.
 
The query depth info.
 
This gives you access to the immediate directives on a MergedField.
 
 
These objects are ALWAYS in the context of a single MergedField
 
Used by QueryTraverser to reduce the fields of a Document (or part of it) to a single value.
Helps to transform a Document (or parts of it) and tracks at the same time the corresponding Schema types.
 
QueryTraverser helper class that maintains traversal context as the query traversal algorithm traverses down the Selection AST
Helps to traverse (or reduce) a Document (or parts of it) and tracks at the same time the corresponding Schema types.
 
Used by QueryTraverser to visit the nodes of a Query.
 
 
This describes the tree structure that forms from a argument input type, especially with `input ComplexType { ....}` types that might in turn contain other complex types and hence form a tree of values.
 
 
 
 
 
 
 
 
 
 
 
 
Holds raw variables, which have not been coerced yet into CoercedVariables
This can be used to compose graphql runtime types that implement that Relay specification.
 
Special class to be set as var in TraverserContext.setVar(Class, Object) to indicate that the current node should be replaced.
 
This class is used to track the number of result nodes that have been created during execution.
As a graphql query is executed, each field forms a hierarchical path from parent field to child field and this class represents that path as a series of segments.
 
A runtime wiring is a specification of data fetchers, type resolvers and custom scalars that are needed to wire together a functional GraphQLSchema
 
This reader will only emit a maximum number of characters from it.
This token source can wrap a lexer and if it asks for more than a maximum number of tokens the user can take some action, typically throw an exception to stop lexing.
Info on all the standard scalar objects provided by graphql-java
 
This contains the implementations of the Scalar types that ship with graphql-java.
 
 
 
 
 
 
 
 
The SchemaDiff is called with a DiffSet and will report the differences in the graphql schema APIs by raising events to a DifferenceReporter
 
Options for controlling the diffing process
Any kind of difference between two schemas is a SchemaDifference.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SCHEMA, SCALAR, OBJECT, FIELD_DEFINITION, ARGUMENT_DEFINITION, INTERFACE, UNION, ENUM, ENUM_VALUE, INPUT_OBJECT, INPUT_FIELD_DEFINITION
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Interface used to define 2 schemas that can be diffed by the SchemaDiff operation.
A SchemaDirectiveWiring is responsible for enhancing a runtime element based on directives placed on that element in the Schema Definition Language (SDL).
SchemaDirectiveWiring is passed this object as parameters when it builds out behaviour
 
 
 
 
 
 
 
This can generate a working runtime schema from a type registry and runtime wiring
These options control how the schema generation works
This contains helper code to build out appliedm directives on schema element
This contains the helper code that allows SchemaDirectiveWiring implementations to be invoked during schema generation.
 
 
 
 
We pass this around so we know what we have defined in a stack like manner plus it gives us helper functions
Deprecated.
This mechanism can be achieved in a better way via SchemaTransformer after the schema is built
 
 
 
This class will track what order SDLDefinition were parsed in via SchemaParser and TypeDefinitionRegistry
This can take a graphql schema definition and parse it into a TypeDefinitionRegistry of definitions ready to be placed into SchemaGenerator say
This can print an in memory GraphQL schema back to a logical schema definition
Options to use when printing a schema
 
A number of problems can occur when using the schema tools like SchemaParser or SchemaGenerator classes and they are reported via this exception as a list of GraphQLErrors
 
Transforms a GraphQLSchema object by calling bac on a provided visitor.
 
 
 
 
 
 
This helps pre check the state of the type system to ensure it can be made into an executable schema.
This is responsible for traversing EVERY type and field in the registry and ensuring that any directives used follow the directive definition rules, for example field directives can be used on object types
A support class to help break up the large SchemaTypeChecker class.
This class shows schema usage information.
 
 
 
 
Error in graphql schema validation can have a classification, and all the error classifications implement this interface.
 
 
 
An interface for Schema Definition Language (SDL) definitions.
A marker interface for Schema Definition Language (SDL) extension definitions.
A interface for named Schema Definition Language (SDL) definition.
A SelectedField represents a field that occurred in a query selection set during execution and they are returned from using the DataFetchingFieldSelectionSet interface returned via DataFetchingEnvironment.getSelectionSet()
 
 
 
 
 
The standard handling of data fetcher error involves placing a ExceptionWhileDataFetching error into the error collection
This very simple field validation will run the supplied function for a given field path and if it returns an error it will be added to the list of problems.
Deprecated.
use SimplePerformantInstrumentation instead as a base class.
A simple implementation of InstrumentationContext
 
An implementation of Instrumentation that does nothing.
A Publisher of things that are buffered and handles a single subscriber at a time.
This is called when a subscription is made to the publisher
 
A DataFetcher that always returns the same value
 
 
Contains parsing code for the StringValue types in the grammar
This class returns a list of strongly connected components (SCC) which are topologically sorted.
An execution strategy that implements graphql subscriptions by using reactive-streams as the output result of the subscription query.
Subscription queries return an instance of this class in the ExecutionResult data element for the subscribed field.
A subscription operation must only have one root field A subscription operation's single root field must not be an introspection field https://spec.graphql.org/draft/#sec-Single-root-field
This represents code that is known to be mutable but thread safe.
This Instrumentation implementation uses TracingSupport to capture tracing information and puts it into the ExecutionResult
 
This creates a map of tracing information as outlined in https://github.com/apollographql/apollo-tracing
A simple object that you need to call TracingSupport.TracingContext.onEnd() on
 
Special traversal control values
 
Traversal context.
 
 
 
 
 
 
 
 
 
 
 
 
Mark a DataFetcher as trivial: If a data fetcher is simply mapping data from an object to a field, it can be considered a trivial data fetcher for the purposes of tracing and so on.
 
The validation about GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType.
An interface for type definitions in a Schema Definition Language (SDL).
A TypeDefinitionRegistry contains the set of type definitions that come from compiling a graphql schema definition file via SchemaParser.parse(String)
 
 
 
 
 
This helper gives you access to the type info given a type definition
And enumeration of the the kind of things that can be in a graphql type system
 
 
 
 
 
This is passed to a TypeResolver to help with object type resolution.
This class is a classic builder style one that SHOULD have been on have been on TypeResolutionEnvironment but for legacy reasons was not.
 
This is called during type resolution to work out what concrete GraphQLObjectType should be used dynamically during runtime for GraphQLInterfaceTypes and GraphQLUnionTypes
 
A type runtime wiring is a specification of the data fetchers and possible type resolver for a given type name.
 
Schema validation rule ensuring object and interface types have all the fields that they need to implement the interfaces they say they implement.
This class consists of static utility methods for operating on Type.
 
Contains Unicode helpers for parsing StringValue types in the grammar
 
 
 
 
 
UnionType check, details in https://spec.graphql.org/June2018/#sec-Type-System.
 
Unique argument names A GraphQL field or directive is only valid if all supplied arguments are uniquely named.
https://facebook.github.io/graphql/June2018/#sec-Directives-Are-Unique-Per-Location
 
 
A GraphQL document is only valid if all defined operations have unique names.
Unique variable names
This is thrown if multiple operations are defined in the query and the operation name is missing or there is no matching operation name contained in the GraphQL query.
 
This is thrown if a TypeResolver fails to give back a concrete type or provides a type that doesn't implement the given interface or union.
 
 
 
 
 
 
Indicates that that maximum number of validation errors has been reached
 
 
 
 
 
 
This class, originally broken out from ValuesResolver contains code for the conversion of values from one form (literal, external etc..) to another.
 
 
This class allows you to traverse a set of input values according to the type system and optional change the values present.
 
A value unboxer takes values that are wrapped in classes like Optional / OptionalInt etc..
A visitor callback used by ValueTraverser
Represents the elements that leads to a value and type
This accumulator class decides on whether to create a variable for a query argument and if so it tracks what variables were made.
 
 
 
This predicate indicates whether a variable should be made for this field argument OR whether it will be compiled into a graphql AST literal.
 
 
 
 
 
 
 
 
Predicate used during a FieldVisibilitySchemaTransformation to test whether a field should be visible.
Container to pass additional context about a schema element (ie., field) to VisibleFieldPredicate.
 
Marks fields, methods etc as more visible than actually needed for testing purposes.
 
A WiringFactory allows you to more dynamically wire in TypeResolvers and DataFetchers based on the IDL definitions.