Modifier and Type | Class and Description |
---|---|
class |
AssertException |
interface |
ErrorClassification
Errors in graphql-java can have a classification to help with the processing
of errors.
|
class |
ErrorType
All the errors in graphql belong to one of these categories
|
class |
ExceptionWhileDataFetching
This graphql error will be used if a runtime exception is encountered while a data fetcher is invoked
|
class |
ExecutionInput
This represents the series of values that can be input on a graphql query execution
|
interface |
ExecutionResult
This simple value class represents the result of performing a graphql query.
|
class |
GraphQL
This class is where all graphql-java query execution begins.
|
static class |
GraphQL.Builder |
class |
GraphQLContext
This context object can be used to contain key values that can be useful as "context" when executing
DataFetcher s |
interface |
GraphQLError
The interface describing graphql errors
NOTE: This class implements
Serializable and hence it can be serialised and placed into a distributed cache. |
class |
GraphqlErrorBuilder
This helps you build
GraphQLError s and also has a quick way to make a DataFetcherResult s
from that error. |
class |
SerializationError |
class |
TypeMismatchError |
class |
UnresolvedTypeError |
Modifier and Type | Interface and Description |
---|---|
interface |
FieldComplexityCalculator
Used to calculate the complexity of a field.
|
class |
FieldComplexityEnvironment |
class |
MaxQueryComplexityInstrumentation
Prevents execution if the query complexity is greater than the specified maxComplexity.
|
class |
MaxQueryDepthInstrumentation
Prevents execution if the query depth is greater than the specified maxDepth.
|
class |
QueryComplexityInfo
The query complexity info.
|
static class |
QueryComplexityInfo.Builder |
class |
QueryDepthInfo
The query depth info.
|
static class |
QueryDepthInfo.Builder |
interface |
QueryReducer<T>
Used by
QueryTraversal to reduce the fields of a Document (or part of it) to a single value. |
class |
QueryTransformer
Helps to transform a Document (or parts of it) and tracks at the same time the corresponding Schema types.
|
static class |
QueryTransformer.Builder |
class |
QueryTraversal
Helps to traverse (or reduce) a Document (or parts of it) and tracks at the same time the corresponding Schema types.
|
static class |
QueryTraversal.Builder |
interface |
QueryVisitor
Used by
QueryTraversal to visit the nodes of a Query. |
interface |
QueryVisitorFieldEnvironment |
interface |
QueryVisitorFragmentDefinitionEnvironment |
interface |
QueryVisitorFragmentSpreadEnvironment |
interface |
QueryVisitorInlineFragmentEnvironment |
class |
QueryVisitorStub |
Modifier and Type | Class and Description |
---|---|
class |
CacheControl
This class implements the graphql Cache Control specification as outlined in https://github.com/apollographql/apollo-cache-control
|
Modifier and Type | Class and Description |
---|---|
class |
AbortExecutionException
This Exception indicates that the current execution should be aborted.
|
class |
DataFetcherExceptionHandlerParameters
The parameters available to
DataFetcherExceptionHandler s |
class |
DataFetcherExceptionHandlerResult
The result object for
DataFetcherExceptionHandler s |
class |
DataFetcherResult<T>
An object that can be returned from a
DataFetcher that contains both data, local context and errors to be relativized and
added to the final result. |
class |
ExecutionContext |
class |
ExecutionContextBuilder |
class |
ExecutionPath
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.
|
class |
ExecutionStepInfo
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.
|
class |
ExecutionStrategyParameters
The parameters that are passed to execution strategies
|
class |
ExecutorServiceExecutionStrategy
Deprecated.
Use
AsyncExecutionStrategy and CompletableFuture.supplyAsync(java.util.function.Supplier, java.util.concurrent.Executor)
in your data fetchers instead. |
class |
FieldValueInfo |
class |
InputMapDefinesTooManyFieldsException
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.
|
class |
MergedField
This represent all Fields in a query which overlap and are merged into one.
|
class |
MergedSelectionSet |
class |
MissingRootTypeException
This is thrown if a query is attempting to perform an operation not defined in the GraphQL schema
|
class |
NonNullableValueCoercedAsNullException
This is thrown if a non nullable value is coerced to a null value
|
class |
TypeResolutionParameters |
class |
UnknownOperationException
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.
|
class |
UnresolvedTypeException
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. |
Modifier and Type | Class and Description |
---|---|
class |
BatchedExecutionStrategy
Deprecated.
This has been deprecated in favour of using
AsyncExecutionStrategy and DataLoaderDispatcherInstrumentation |
Modifier and Type | Class and Description |
---|---|
class |
ChainedInstrumentation
This allows you to chain together a number of
Instrumentation implementations
and run them in sequence. |
class |
DocumentAndVariables |
class |
SimpleInstrumentation
An implementation of
Instrumentation that does nothing. |
class |
SimpleInstrumentationContext<T>
A simple implementation of
InstrumentationContext |
Modifier and Type | Interface and Description |
---|---|
interface |
FieldAndArguments
This represents a field and its arguments that may be validated.
|
interface |
FieldValidationEnvironment
This contains all of the field and their arguments for a given query.
|
class |
FieldValidationInstrumentation
This
Instrumentation allows you to validate the fields
of the query before the query is executed. |
class |
SimpleFieldValidation
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.
|
Modifier and Type | Class and Description |
---|---|
class |
InstrumentationExecutionParameters
Parameters sent to
Instrumentation methods |
Modifier and Type | Class and Description |
---|---|
class |
TracingInstrumentation
This
Instrumentation implementation uses TracingSupport to
capture tracing information and puts it into the ExecutionResult |
class |
TracingSupport
This creates a map of tracing information as outlined in https://github.com/apollographql/apollo-tracing
|
Modifier and Type | Class and Description |
---|---|
class |
ResultNodeAdapter |
Modifier and Type | Class and Description |
---|---|
class |
Introspection |
class |
IntrospectionResultToSchema |
Modifier and Type | Class and Description |
---|---|
class |
AbstractNode<T extends Node> |
class |
Argument |
class |
ArrayValue |
class |
AstNodeAdapter
Adapts an Ast node to the general node from the util package
|
class |
AstPrinter
This can take graphql language AST and print it out as a string
|
class |
AstSignature
This will produce signature query documents that can be used say for logging.
|
class |
AstSorter
A class that helps you sort AST nodes
|
class |
AstTransformer
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.
|
class |
BooleanValue |
class |
Comment |
interface |
Definition<T extends Definition> |
class |
Description |
class |
Directive |
class |
DirectiveDefinition |
class |
DirectiveLocation |
interface |
DirectivesContainer<T extends DirectivesContainer>
Represents a language node that can contain Directives.
|
class |
Document |
class |
EnumTypeDefinition |
class |
EnumTypeExtensionDefinition |
class |
EnumValue |
class |
EnumValueDefinition |
class |
Field |
class |
FieldDefinition |
class |
FloatValue |
class |
FragmentDefinition
Provided to the DataFetcher, therefore public API
|
class |
FragmentSpread |
class |
IgnoredChar |
class |
IgnoredChars |
class |
InlineFragment |
class |
InputObjectTypeDefinition |
class |
InputObjectTypeExtensionDefinition |
class |
InputValueDefinition |
class |
InterfaceTypeDefinition |
class |
InterfaceTypeExtensionDefinition |
class |
IntValue |
class |
ListType |
interface |
NamedNode<T extends NamedNode>
Represents a language node that has a name
|
interface |
Node<T extends Node>
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. |
interface |
NodeBuilder |
class |
NodeChildrenContainer
Container of children of a
Node . |
interface |
NodeDirectivesBuilder |
class |
NodeParentTree<T extends Node>
This represents a hierarchy from a graphql language node upwards to its
associated parent nodes.
|
class |
NodeTraverser
Lets you traverse a
Node tree. |
interface |
NodeVisitor
Used by
NodeTraverser to visit Node . |
class |
NodeVisitorStub
Convenient implementation of
NodeVisitor for easy subclassing methods handling different types of Nodes in one method. |
class |
NonNullType |
class |
NullValue |
class |
ObjectField |
class |
ObjectTypeDefinition |
class |
ObjectTypeExtensionDefinition |
class |
ObjectValue |
class |
OperationDefinition |
class |
OperationTypeDefinition |
class |
ScalarTypeDefinition |
class |
ScalarTypeExtensionDefinition |
interface |
ScalarValue<T extends Value> |
class |
SchemaDefinition |
interface |
SDLDefinition<T extends SDLDefinition>
All Schema Definition Language (SDL) Definitions.
|
interface |
Selection<T extends Selection> |
class |
SelectionSet |
interface |
SelectionSetContainer<T extends Node> |
class |
SourceLocation |
class |
StringValue |
interface |
Type<T extends Type> |
interface |
TypeDefinition<T extends TypeDefinition>
All type definitions in a SDL.
|
class |
TypeKind
And enumeration of the the kind of things that can be in a graphql type system
|
class |
TypeName |
class |
UnionTypeDefinition |
class |
UnionTypeExtensionDefinition |
interface |
Value<T extends Value> |
class |
VariableDefinition |
class |
VariableReference |
Modifier and Type | Class and Description |
---|---|
class |
MultiSourceReader
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.
|
Modifier and Type | Interface and Description |
---|---|
interface |
Connection<T>
|
interface |
ConnectionCursor
Represents a
connection cursor in Relay which is an opaque
string that the server understands. |
class |
DefaultConnection<T>
A default implementation of
Connection |
class |
DefaultConnectionCursor |
class |
DefaultEdge<T> |
class |
DefaultPageInfo |
interface |
Edge<T>
Represents an edge in Relay which is essentially a node of data T and the cursor for that node.
|
interface |
PageInfo
Represents pagination information in Relay about
edges when used
inside a connection
See https://facebook.github.io/relay/graphql/connections.htm#sec-undefined.PageInfo |
class |
Relay
This can be used to compose graphql runtime types that implement
that Relay specification.
|
class |
SimpleListConnection<T> |
Modifier and Type | Class and Description |
---|---|
class |
AsyncDataFetcher<T>
A modifier type that indicates the underlying data fetcher is run asynchronously
|
class |
CoercingParseLiteralException |
class |
CoercingParseValueException |
class |
CoercingSerializeException |
class |
DataFetcherFactories
A helper for
DataFetcherFactory |
class |
DataFetcherFactoryEnvironment
This is passed to a
DataFetcherFactory when it is invoked to
get a DataFetcher |
interface |
DataFetchingEnvironment
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 |
class |
FieldCoordinates
A field in graphql is uniquely located within a parent type and hence code elements
like
DataFetcher need to be specified using those coordinates. |
class |
GraphQLArgument
This defines an argument that can be supplied to a graphql field (via
GraphQLFieldDefinition . |
class |
GraphQLCodeRegistry
The
GraphQLCodeRegistry holds that execution code that is associated with graphql types, namely
the DataFetcher s associated with fields, the TypeResolver s associated with
abstract types and the GraphqlFieldVisibility
For legacy reasons these code functions can still exist on the original type objects but this will be removed in a future version. |
interface |
GraphQLCompositeType |
class |
GraphQLDirective
A directive can be used to modify the behavior of a graphql field or type.
|
class |
GraphqlElementParentTree
This represents a hierarchy an graphql runtime element upwards to its
associated parent elements.
|
class |
GraphQLEnumType
A graphql enumeration type has a limited set of values.
|
class |
GraphQLEnumValueDefinition
A graphql enumeration type has a limited set of values and this defines one of those unique values
See http://graphql.org/learn/schema/#enumeration-types for more details
|
static class |
GraphQLEnumValueDefinition.Builder |
class |
GraphQLFieldDefinition
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. |
static class |
GraphQLFieldDefinition.Builder |
interface |
GraphQLFieldsContainer
Types that can contain output fields are marked with this interface
|
interface |
GraphQLInputFieldsContainer
Types that can contain input fields are marked with this interface
|
class |
GraphQLInputObjectField
Input objects defined via
GraphQLInputObjectType contains these input fields. |
static class |
GraphQLInputObjectField.Builder |
class |
GraphQLInputObjectType
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.
|
static class |
GraphQLInputObjectType.Builder |
interface |
GraphQLInputType
Input types represent those set of types that are allowed to be accepted as graphql mutation input, as opposed
to
GraphQLOutputType s which can only be used as graphql response output. |
class |
GraphQLInterfaceType
In graphql, an interface is an abstract type that defines the set of fields that a type must include to
implement that interface.
|
static class |
GraphQLInterfaceType.Builder |
class |
GraphQLList
A modified type that indicates there is a list of the underlying wrapped type, eg a list of strings or a list of booleans.
|
class |
GraphQLNonNull
A modified type that indicates there the underlying wrapped type will not be null.
|
class |
GraphQLObjectType
This is the work horse type and represents an object with one or more field values that can be retrieved
by the graphql system.
|
static class |
GraphQLObjectType.Builder |
interface |
GraphQLOutputType
Output types represent those set of types that are allowed to be sent back as a graphql response, as opposed
to
GraphQLInputType s which can only be used as graphql mutation input. |
static class |
GraphQLScalarType.Builder |
class |
GraphQLSchema
The schema represents the combined type system of the graphql engine.
|
interface |
GraphQLType
All types in graphql have a name
|
class |
GraphQLTypeReference
A special type to allow a object/interface types to reference itself.
|
class |
GraphQLTypeUtil
A utility class that helps work with
GraphQLType s |
interface |
GraphQLTypeVisitor |
class |
GraphQLTypeVisitorStub
Base implementation of
GraphQLTypeVisitor for convenience. |
class |
GraphQLUnionType
A union type is a polymorphic type that dynamically represents one of more concrete object types.
|
static class |
GraphQLUnionType.Builder |
class |
PropertyDataFetcher<T>
This is the default data fetcher used in graphql-java.
|
interface |
SelectedField
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() |
class |
StaticDataFetcher
A
DataFetcher that always returns the same value |
class |
TypeTraverser |
Modifier and Type | Class and Description |
---|---|
class |
DiffCategory
A classification of difference events.
|
class |
DiffEvent
This represents the events that the
SchemaDiff outputs. |
class |
DiffLevel
This is the level of difference between graphql APIs
|
class |
DiffSet
Represents 2 schemas that can be diffed.
|
Modifier and Type | Class and Description |
---|---|
class |
CapturingReporter
A reporter that captures all the difference events as they occur
|
class |
ChainedReporter
A reporter that chains together one or more difference reporters
|
class |
PrintStreamReporter
A reporter that prints its output to a PrintStream
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultSchemaPrinterComparatorRegistry
Associates a
Comparator with a SchemaPrinterComparatorEnvironment to control the scope in which the Comparator can be applied. |
class |
FieldWiringEnvironment |
class |
InterfaceWiringEnvironment |
class |
MapEnumValuesProvider |
class |
NaturalEnumValuesProvider<T extends Enum<T>>
Simple EnumValuesProvided which maps the GraphQL Enum name to the Java Enum instance.
|
class |
RuntimeWiring
A runtime wiring is a specification of data fetchers, type resolvers and custom scalars that are needed
to wire together a functional
GraphQLSchema |
static class |
RuntimeWiring.Builder |
class |
ScalarWiringEnvironment |
interface |
SchemaDirectiveWiring
A SchemaDirectiveWiring is responsible for enhancing a runtime element based on directives placed on that
element in the Schema Definition Language (SDL).
|
interface |
SchemaDirectiveWiringEnvironment<T extends GraphQLDirectiveContainer>
SchemaDirectiveWiring is passed this object as parameters
when it builds out behaviour |
class |
SchemaGenerator
This can generate a working runtime schema from a type registry and runtime wiring
|
class |
SchemaParser
This can take a graphql schema definition and parse it into a
TypeDefinitionRegistry of
definitions ready to be placed into SchemaGenerator say |
class |
SchemaPrinter
This can print an in memory GraphQL schema back to a logical schema definition
|
class |
SchemaPrinterComparatorEnvironment
Defines the scope to control where the registered
Comparator can be applied. |
class |
TypeDefinitionRegistry
A
TypeDefinitionRegistry contains the set of type definitions that come from compiling
a graphql schema definition file via SchemaParser.parse(String) |
class |
UnionWiringEnvironment |
Modifier and Type | Class and Description |
---|---|
class |
BlockedFields
This helper class will take a list of regular expressions and match them against the fully qualified name
of a type and its fields.
|
interface |
GraphqlFieldVisibility
This allows you to control the visibility of graphql fields.
|
Modifier and Type | Class and Description |
---|---|
class |
Breadcrumb<T>
A specific
NodeLocation inside a node. |
interface |
NodeAdapter<T>
Adapts an arbitrary class to behave as a node.
|
class |
NodeLocation
General position of a Node inside a parent.
|
class |
NodeMultiZipper<T> |
class |
NodeZipper<T> |
class |
TraversalControl
Special traversal control values
|
interface |
TraverserContext<T>
Traversal context.
|
class |
TreeTransformer<T> |
class |
TreeTransformerUtil |
Copyright © 2019. All rights reserved.