All Classes and Interfaces
Class
Description
This Exception indicates that the current execution should be aborted.
Contains data relevant to the execution of a
DeferredFragmentCall and Subscription events.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().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
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 builder of materialized objects or
CompletableFutures than can present a promise to the list of themA 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.
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 but keeps the results
in order of downstream publishing.
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 subscriber can be used to map between a
Publisher of U
elements and map them into CompletionStage of D promises, and it keeps them in the order
the Publisher provided them.This subscriber can be used to map between a
Publisher of U
elements and map them into CompletionStage of D promises.This callback interface allows custom implementations to decide if a field is included in a query or not.
The parameters given to a
ConditionalNodeDecisionRepresents a
connection cursor in Relay which is an opaque
string that the server understands.Custom contract annotation used for jspecify and NullAway checks.
Finds all cycles in a GraphQL Schema.
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) executionThe parameters available to
DataFetcherExceptionHandlersThe result object for
DataFetcherExceptionHandlersA helper for
DataFetcherFactoryA DataFetcherFactory allows a level of indirection in providing
DataFetchers for graphql fields.Deprecated.
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 inputThis class allows you to retrieve the selection set of fields that have been asked for when the
DataFetcher was invoked.GraphQLContext keys related to DataLoader dispatching.
A default implementation of
ConnectionThe 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.Implements the contract of
ResponseMapFactory with LinkedHashMap.Public API because it should be used as a delegate when implementing a custom
ValueUnboxerDefer and stream directive labels are unique
A GraphQL document is only valid if defer and stream directives' label argument is static and unique.
Defer and stream directives are used on valid root field
A GraphQL document is only valid if defer directives are not used on root mutation or subscription types.
Defer Directive is Used On Valid Operations
A GraphQL document is only valid if defer directives are not used on subscription types.
Represents a defer payload
Represents details about the defer execution that can be associated with a
MergedField.The purpose of this class hierarchy is to encapsulate most of the logic for deferring field execution, thus
keeping the main execution strategy code clean and focused on the main execution logic.
An implementation that actually executes the deferred fields.
A no-op implementation that should be used when incremental support is not enabled for the current execution.
Represents a deferred call (aka @defer) to get an execution result sometime after the initial query has returned.
See
DataLoaderDispatchingContextKeys for how to set it.Represents a result that is delivered asynchronously, after the initial
IncrementalExecutionResult.DelegatingDataFetchingEnvironment implements
DataFetchingEnvironment by delegating
to an underlying instance.A simple subscription that delegates to another
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 operationThis 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
An annotation that marks a method return value or method parameter as returning a duck type value.
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
This class lets you observe the running state of the graphql-java engine.
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
may be 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
ExecutionIdsThis 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 is the result of the agent tracking an execution.
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 or 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.
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.FieldFetchingInstrumentationContext is returned back from the
Instrumentation.beginFieldFetching(InstrumentationFieldFetchParameters, InstrumentationState)
method, and it's much like the normal InstrumentationContext type except it also
gives the value that was returned by a fields DataFetcher.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.The
FieldValueInfo holds the type of field that was fetched and completed along with the completed value.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.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 GraphqlFieldVisibilityThis context object can be used to contain key values that can be useful as "context" when executing
DataFetchersA 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
GraphQLErrorsThis 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.
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) sayThis visitor interface offers more "smarts" above
GraphQLTypeVisitor and aims to be easier to use
with more type safe helpers.A
GraphQLSchemaVisitorEnvironment environment specific to GraphQLAppliedDirectiveArgumentA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLAppliedDirectiveA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLArgumentA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLEnumTypeA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLEnumValueDefinitionA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLFieldDefinitionA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLInputObjectFieldA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLInputObjectTypeA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLInterfaceTypeA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLObjectTypeA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLScalarTypeA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLSchemaElementA
GraphQLSchemaVisitorEnvironment environment specific to GraphQLUnionTypeThe 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
GraphQLTypesGraphQLTypeVisitor 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.
This allows you to control "unusual" aspects of the GraphQL system
including some JVM wide settings and some per execution settings
as well as experimental ones.
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
An id generator that uses
SecureRandom for the initial seed and
Random thereafter.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
ImmutableTypeDefinitionRegistry contains an immutable set of type definitions that come from compiling
a graphql schema definition file via SchemaParser.parse(String) and is more performant because it
uses ImmutableMap structures.A
TypeDefinition that might implement interfacesRepresents an incremental call (resulted from the usage of @defer or @stream).
This provides support for @defer directives on fields that mean that results will be sent AFTER
the main result is sent via a Publisher stream.
A result that is part of an execution that includes incrementally delivered data (data has been deferred of streamed).
Represents a payload that can be resolved after the initial response.
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 methodsParameters sent to
Instrumentation methodsParameters sent to
Instrumentation methodsParameters sent to
Instrumentation methodsParameters sent to
Instrumentation methodsParameters sent to
Instrumentation methodsParameters sent to
Instrumentation methodsAn
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 executionParameters sent to
Instrumentation methodsThis represents code that the graphql-java project considers internal code that MAY not be stable within
major releases.
Interner allowing object-identity comparison of key entities like field names.
This memoizing supplier DOES use locked double locking to set its 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
IntrospectionExtracted from
DataFetchingEnvironment to only capture
the data really needed for IntrospectionIntrospectionQueryBuilder allows you to build introspection queries controlled
by the options you specifyThe 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.DirectivePredicateThis exception is thrown by the
Parser if the graphql syntax is not validUnique variable names
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
This is a
WiringFactory which provides mocked types resolver
and scalars.A delegating type visitor that allows you to call N visitors in a list
and always continues via
TraversalControl.CONTINUEThis 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
NodesUsed 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 insteadThis 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
Represents details about the defer execution that can be associated with a
ExecutableNormalizedField.An
NormalizedField represents a field in an executable graphql operation.An argument value with type information.
A
NormalizedOperation 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 class can take a list of
NormalizedFields and compiling out a
normalised operation Document that would represent how those fields
may be executed.The result is a
Document and a map of variables
that would go with that document.Holds coerced variables, that is their values are now in a normalized
NormalizedInputValue form.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.PageInfoThis 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
DocumentThis is the arguments that can be passed to a
ParserOptions 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
Generates a GraphQL query string based on the provided operation field path, operation name, arguments, and type classifier.
Options for the
QueryGenerator class.Builder for
QueryGeneratorOptions.Represents the result of a query generation process.
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.
This options object controls how
QueryTraverser worksHelps 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
CoercedVariablesThis provides support for a DataFetcher to be able to
return a reactive streams
Publisher or Java JDK Flow.Publisher
as a value, and it can be turned into a CompletableFuture
that we can get an async value from.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.Allows to customize the concrete class
Map implementation.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
GraphQLSchemaThis 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
DifferenceReporterOptions 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 behaviourThis can generate a working runtime schema from a type registry and runtime wiring
These options control how the schema generation works
This contains the helper code that allows
SchemaDirectiveWiring implementations
to be invoked during schema generation.This class will track what order
SDLDefinition were parsed in
via SchemaParser and TypeDefinitionRegistryThis can take a graphql schema definition and parse it into a
TypeDefinitionRegistry of
definitions ready to be placed into SchemaGenerator sayThis 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 GraphQLErrorsTransforms 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 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 collectionThis 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
InstrumentationContextAn 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
The
SingletonPropertyDataFetcher is much like the PropertyDataFetcher except
that it is designed to only ever fetch properties via the name of the field passed in.A
DataFetcher that always returns the same valueRepresents a call that fetches data that was streamed, via the @stream directive.
Represents a stream payload
An exception that is throw when
RuntimeWiring.Builder.strictMode(boolean) or TypeRuntimeWiring.Builder.strictMode(boolean) is true and
something gets redefined.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 ExecutionResultThis 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() onSpecial 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 GraphQLUnionTypesA 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
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.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
ValueTraverserRepresents 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.
GraphQLFieldDefinition