All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AbortExecutionException |
This Exception indicates that the current execution should be aborted.
|
| AbstractAsyncExecutionStrategy |
|
| AbstractDescribedNode<T extends Node> |
|
| AbstractNode<T extends Node> |
|
| AbstractRule |
|
| Anonymizer |
Util class which converts schemas and optionally queries
into anonymized schemas and queries.
|
| Anonymizer.AnonymizeResult |
|
| AntlrHelper |
|
| ApolloPersistedQuerySupport |
|
| AppliedDirectiveArgumentsAreValid |
|
| AppliedDirectivesAreValid |
|
| Argument |
|
| Argument.Builder |
|
| ArgumentsOfCorrectType |
|
| ArgumentValidationUtil |
|
| ArgValueOfAllowedTypeChecker |
Class to check whether a given directive argument value
matches a given directive definition.
|
| ArrayValue |
|
| ArrayValue.Builder |
|
| Assert |
|
| AssertException |
|
| AstComparator |
|
| AstNodeAdapter |
Adapts an Ast node to the general node from the util package
|
| AstPrinter |
This can take graphql language AST and print it out as a string
|
| AstPrinter.NodePrinter<T extends Node> |
These print nodes into output writers
|
| AstSignature |
This will produce signature and privacy safe query documents that can be used for query categorisation and logging.
|
| AstSorter |
A class that helps you sort AST nodes
|
| 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.
|
| Async |
|
| Async.CombinedBuilder<T> |
|
| Async.Empty<T> |
|
| Async.Many<T> |
|
| Async.Single<T> |
|
| AsyncDataFetcher<T> |
A modifier type that indicates the underlying data fetcher is run asynchronously
|
| AsyncExecutionStrategy |
The standard graphql execution strategy that runs fields asynchronously non-blocking.
|
| AsyncSerialExecutionStrategy |
Async non-blocking execution, but serial: only one field at the time will be resolved.
|
| BaseError |
|
| 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.
|
| BlockedFields.Builder |
|
| BooleanValue |
|
| BooleanValue.Builder |
|
| Breadcrumb<T> |
|
| CapturingReporter |
A reporter that captures all the difference events as they occur
|
| ChainedInstrumentation |
This allows you to chain together a number of Instrumentation implementations
and run them in sequence. |
| ChainedInstrumentation.ChainedExecutionStrategyInstrumentationContext |
|
| ChainedInstrumentation.ChainedInstrumentationContext<T> |
|
| ChainedInstrumentation.ChainedInstrumentationState |
|
| ChainedReporter |
A reporter that chains together one or more difference reporters
|
| CodeRegistryVisitor |
This ensure that all fields have data fetchers and that unions and interfaces have type resolvers
|
| CoercedVariables |
Holds coerced variables, that is their values are now in a canonical form.
|
| Coercing<I,O> |
The Coercing interface is used by GraphQLScalarTypes to parse and serialize object values. |
| CoercingParseLiteralException |
|
| CoercingParseLiteralException.Builder |
|
| CoercingParseValueException |
|
| CoercingParseValueException.Builder |
|
| CoercingSerializeException |
|
| CoercingSerializeException.Builder |
|
| CoercingUtil |
|
| CombinedWiringFactory |
|
| Comment |
A single-line comment.
|
| CommentParser |
Contains methods for extracting Comment in various positions within and around Nodes |
| CompletionStageMappingPublisher<D,U> |
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
|
| ConditionalNodeDecision |
This callback interface allows custom implementations to decide if a field is included in a query or not.
|
| ConditionalNodeDecisionEnvironment |
|
| ConditionalNodes |
|
| Connection<T> |
This represents a connection in Relay, which is a list of edges
as well as a pageInfo that describes the pagination of that list. |
| ConnectionCursor |
Represents a connection cursor in Relay which is an opaque
string that the server understands. |
| DataFetcher<T> |
A data fetcher is responsible for returning a data value back for a given graphql field.
|
| DataFetcherExceptionHandler |
|
| DataFetcherExceptionHandlerParameters |
|
| DataFetcherExceptionHandlerParameters.Builder |
|
| DataFetcherExceptionHandlerResult |
|
| DataFetcherExceptionHandlerResult.Builder |
|
| DataFetcherFactories |
|
| DataFetcherFactory<T> |
A DataFetcherFactory allows a level of indirection in providing DataFetchers for graphql fields. |
| DataFetcherFactoryEnvironment |
|
| DataFetcherFactoryEnvironment.Builder |
|
| DataFetcherResult<T> |
An object that can be returned from a DataFetcher that contains both data, local context and errors to be added to the final result. |
| DataFetcherResult.Builder<T> |
|
| 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 |
| DataFetchingEnvironmentImpl |
|
| DataFetchingEnvironmentImpl.Builder |
|
| DataFetchingFieldSelectionSet |
This class allows you to retrieve the selection set of fields that have been asked for when the
DataFetcher was invoked. |
| DataFetchingFieldSelectionSetImpl |
|
| DataFetchingFieldSelectionSetImpl.SelectedFieldImpl |
|
| DataLoaderDispatcherInstrumentation |
This graphql Instrumentation will dispatch
all the contained DataLoaders when each level of the graphql
query is executed. |
| DataLoaderDispatcherInstrumentationOptions |
|
| DataLoaderDispatcherInstrumentationState |
A base class that keeps track of whether aggressive batching can be used
|
| DefaultConnection<T> |
|
| DefaultConnectionCursor |
|
| DefaultEdge<T> |
|
| DefaultExtensionsMerger |
|
| DefaultGraphqlFieldVisibility |
The default field visibility of graphql-java is that everything is visible
|
| DefaultGraphqlTypeComparatorRegistry |
Associates a Comparator with a GraphqlTypeComparatorEnvironment to control the scope in which the Comparator can be applied.
|
| DefaultGraphqlTypeComparatorRegistry.Builder |
|
| DefaultPageInfo |
|
| DefaultTraverserContext<T> |
|
| DefaultValuesAreValid |
|
| DefaultValueUnboxer |
Public API because it should be used as a delegate when implementing a custom ValueUnboxer |
| Definition<T extends Definition> |
|
| DelegatingDataFetchingEnvironment |
|
| DelegatingSubscription |
A simple subscription that delegates to another
|
| DeprecatedAt |
Helper to track deprecation
Please use ISO-8601 format i.e.
|
| DescribedNode<T extends Node> |
Represents a node that can contain a description.
|
| Description |
|
| DiffCategory |
A classification of difference events.
|
| DiffCtx |
|
| DifferenceReporter |
This is called with each different encountered (including info ones) by a SchemaDiff operation |
| DiffEvent |
This represents the events that the SchemaDiff outputs. |
| DiffEvent.Builder |
|
| DiffImpl |
This is an algorithm calculating the optimal edit to change the source graph into the target graph.
|
| DiffImpl.MappingEntry |
|
| DiffImpl.OptimalEdit |
An optimal edit from one graph to another.
|
| DiffLevel |
This is the level of difference between graphql APIs
|
| DiffSet |
Deprecated. |
| Directive |
|
| Directive.Builder |
|
| DirectiveDefinition |
|
| DirectiveDefinition.Builder |
|
| DirectiveIllegalArgumentTypeError |
|
| DirectiveIllegalLocationError |
|
| DirectiveIllegalReferenceError |
|
| DirectiveInfo |
Info on all the directives provided by graphql specification
|
| DirectiveLocation |
|
| DirectiveLocation.Builder |
|
| DirectiveMissingNonNullArgumentError |
|
| DirectiveRedefinitionError |
|
| Directives |
The directives that are understood by graphql-java
|
| DirectivesContainer<T extends DirectivesContainer> |
Represents a language node that can contain Directives.
|
| DirectivesResolver |
This turns AST directives into runtime directives with resolved types and so on
|
| DirectivesUtil |
|
| DirectivesUtil.DirectivesHolder |
A holder class that breaks a list of directives into maps to be more easily accessible in using classes
|
| DirectiveUndeclaredError |
|
| DirectiveUnknownArgumentError |
|
| Document |
|
| Document.Builder |
|
| DocumentAndVariables |
|
| DocumentAndVariables.Builder |
|
| DocumentVisitor |
|
| EchoingWiringFactory |
A wiring factory that will echo back the objects defined.
|
| Edge<T> |
Represents an edge in Relay which is essentially a node of data T and the cursor for that node.
|
| Edge |
|
| EditOperation |
An edit operation between two graphs can be one of six types:
insert vertex,
delete vertex,
change vertex,
insert edge,
delete edge,
change edge
|
| EditOperation.Operation |
|
| EditOperationAnalysisResult |
|
| EditOperationAnalyzer |
Higher level GraphQL semantic assigned to
|
| EditorialCostForMapping |
|
| ENFMerger |
|
| EnumTypeDefinition |
|
| EnumTypeDefinition.Builder |
|
| EnumTypeExtensionDefinition |
|
| EnumTypeExtensionDefinition.Builder |
|
| EnumValue |
|
| EnumValue.Builder |
|
| EnumValueDefinition |
|
| EnumValueDefinition.Builder |
|
| EnumValuesProvider |
Provides the Java runtime value for each graphql Enum value.
|
| ErrorClassification |
Errors in graphql-java can have a classification to help with the processing
of errors.
|
| ErrorType |
All the errors in graphql belong to one of these categories
|
| EscapeUtil |
|
| ExceptionWhileDataFetching |
This graphql error will be used if a runtime exception is encountered while a data fetcher is invoked
|
| ExecutableDefinitions |
|
| ExecutableNormalizedField |
|
| ExecutableNormalizedField.Builder |
|
| ExecutableNormalizedOperation |
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. |
| ExecutableNormalizedOperationFactory |
|
| ExecutableNormalizedOperationFactory.CollectedField |
|
| ExecutableNormalizedOperationFactory.CollectedFieldGroup |
|
| ExecutableNormalizedOperationFactory.CollectNFResult |
|
| ExecutableNormalizedOperationFactory.FieldAndAstParent |
|
| ExecutableNormalizedOperationFactory.Options |
|
| ExecutableNormalizedOperationToAstCompiler |
|
| ExecutableNormalizedOperationToAstCompiler.CompilerResult |
The result is a Document and a map of variables
that would go with that document. |
| Execution |
|
| ExecutionContext |
|
| ExecutionContextBuilder |
|
| ExecutionId |
This opaque identifier is used to identify a unique query execution
|
| ExecutionIdProvider |
|
| ExecutionInput |
This represents the series of values that can be input on a graphql query execution
|
| ExecutionInput.Builder |
|
| ExecutionResult |
This simple value class represents the result of performing a graphql query.
|
| ExecutionResult.Builder<B extends ExecutionResult.Builder<B>> |
|
| ExecutionResultImpl |
|
| ExecutionResultImpl.Builder |
|
| 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.
|
| ExecutionStepInfo.Builder |
|
| ExecutionStepInfoFactory |
|
| ExecutionStrategy |
An execution strategy is give a list of fields from the graphql query to execute and find values for using a recursive strategy.
|
| ExecutionStrategyInstrumentationContext |
|
| ExecutionStrategyParameters |
The parameters that are passed to execution strategies
|
| ExecutionStrategyParameters.Builder |
|
| ExecutorInstrumentation |
This instrumentation can be used to control on what thread calls to DataFetchers happen on. |
| ExecutorInstrumentation.Action |
This describes what action is currently being done.
|
| ExecutorInstrumentation.Builder |
|
| ExperimentalApi |
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. |
| ExtendedBailStrategy |
|
| ExtensionsBuilder |
This class can be used to help build the graphql `extensions` map.
|
| ExtensionsMerger |
This interface is a callback asking code to merge two maps with an eye to creating
the graphql `extensions` value.
|
| FetchedValue |
|
| FetchedValue.Builder |
|
| Field |
|
| Field.Builder |
|
| FieldAndArguments |
This represents a field and its arguments that may be validated.
|
| FieldCollector |
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
|
| FieldCollectorNormalizedQueryParams |
|
| FieldCollectorNormalizedQueryParams.Builder |
|
| FieldCollectorNormalizedQueryParams.PossibleMerger |
|
| FieldCollectorParameters |
Internal because FieldCollector is internal.
|
| FieldCollectorParameters.Builder |
|
| FieldComplexityCalculator |
Used to calculate the complexity of a field.
|
| FieldComplexityEnvironment |
|
| 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. |
| FieldDefinition |
|
| FieldDefinition.Builder |
|
| FieldLevelTrackingApproach |
This approach uses field level tracking to achieve its aims of making the data loader more efficient
|
| FieldLevelTrackingApproach.CallStack |
|
| FieldsOnCorrectType |
|
| FieldValidation |
This pluggable interface allows you to validate the fields and their argument inputs before query execution.
|
| FieldValidationEnvironment |
This contains all of the field and their arguments for a given query.
|
| FieldValidationInstrumentation |
This Instrumentation allows you to validate the fields
of the query before the query is executed. |
| FieldValidationSupport |
|
| FieldValidationSupport.FieldAndArgError |
|
| FieldValidationSupport.FieldAndArgumentsImpl |
|
| FieldValidationSupport.FieldValidationEnvironmentImpl |
|
| FieldValueInfo |
|
| FieldValueInfo.Builder |
|
| FieldValueInfo.CompleteValueType |
|
| FieldVisibilitySchemaTransformation |
Transforms a schema by applying a visibility predicate to every field.
|
| FieldVisibilitySchemaTransformation.AdditionalTypeVisibilityVisitor |
|
| FieldVisibilitySchemaTransformation.FieldRemovalVisitor |
|
| FieldVisibilitySchemaTransformation.TypeObservingVisitor |
|
| FieldVisibilitySchemaTransformation.TypeVisibilityVisitor |
|
| FieldWiringEnvironment |
|
| FloatValue |
|
| FloatValue.Builder |
|
| FpKit |
|
| FpKit.ArrayIterator<T> |
|
| FragmentDefinition |
Provided to the DataFetcher, therefore public API
|
| FragmentDefinition.Builder |
|
| FragmentsOnCompositeType |
|
| FragmentSpread |
|
| FragmentSpread.Builder |
|
| GoodFaithIntrospection |
This Instrumentation ensure that a submitted introspection query is done in
good faith. |
| GoodFaithIntrospection.BadFaithIntrospectionError |
|
| GraphQL |
This class is where all graphql-java query execution begins.
|
| GraphQL.Builder |
|
| GraphqlAntlrToLanguage |
|
| GraphQLAppliedDirective |
An applied directive represents the instance of a directive that is applied to a schema element,
as opposed to it definition
|
| GraphQLAppliedDirective.Builder |
|
| GraphQLAppliedDirectiveArgument |
|
| GraphQLAppliedDirectiveArgument.Builder |
|
| GraphQLArgument |
|
| GraphQLArgument.Builder |
|
| GraphqlBaseListener |
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. |
| GraphqlBooleanCoercing |
The deprecated methods still have implementations in case code outside graphql-java is calling them
but internally the call paths have been replaced.
|
| GraphQLCodeRegistry |
|
| GraphQLCodeRegistry.Builder |
|
| GraphQLCompositeType |
|
| GraphQLContext |
This context object can be used to contain key values that can be useful as "context" when executing
DataFetchers |
| GraphQLContext.Builder |
|
| GraphQLDirective |
A directive can be used to modify the behavior of a graphql field or type.
|
| GraphQLDirective.Builder |
|
| GraphQLDirectiveContainer |
|
| GraphqlDirectivesContainerTypeBuilder<B extends GraphqlDirectivesContainerTypeBuilder<B,BASE>,BASE extends GraphqlTypeBuilder<BASE>> |
|
| GraphqlElementParentTree |
This represents a hierarchy an graphql runtime element upwards to its
associated parent elements.
|
| GraphQLEnumType |
A graphql enumeration type has a limited set of values.
|
| GraphQLEnumType.Builder |
|
| GraphQLEnumValueDefinition |
A graphql enumeration type has a limited set of values and this defines one of those unique values
|
| GraphQLEnumValueDefinition.Builder |
|
| GraphQLError |
The interface describing graphql errors
NOTE: This class implements Serializable and hence it can be serialised and placed into a distributed cache.
|
| GraphQLError.Builder<B extends GraphQLError.Builder<B>> |
|
| GraphqlErrorBuilder<B extends GraphqlErrorBuilder<B>> |
|
| GraphqlErrorBuilder.GraphqlErrorImpl |
|
| GraphqlErrorException |
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. |
| GraphqlErrorException.Builder |
|
| GraphqlErrorException.BuilderBase<T extends GraphqlErrorException.BuilderBase<T,B>,B extends GraphqlErrorException> |
A trait like base class that contains the properties that GraphqlErrorException handles and can
be used by other classes to derive their own builders.
|
| GraphqlErrorHelper |
This little helper allows GraphQlErrors to implement
common things (hashcode/ equals ) and to specification more easily
|
| GraphQLException |
|
| 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. |
| GraphQLFieldDefinition.Builder |
|
| GraphQLFieldsContainer |
Types that can contain output fields are marked with this interface
|
| GraphqlFieldVisibility |
This allows you to control the visibility of graphql fields.
|
| GraphqlFloatCoercing |
The deprecated methods still have implementations in case code outside graphql-java is calling them
but internally the call paths have been replaced.
|
| GraphqlIDCoercing |
The deprecated methods still have implementations in case code outside graphql-java is calling them
but internally the call paths have been replaced.
|
| GraphQLImplementingType |
A GraphQLType which can implement interfaces
|
| GraphQLInputFieldsContainer |
Types that can contain input fields are marked with this interface
|
| GraphQLInputObjectField |
|
| GraphQLInputObjectField.Builder |
|
| 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.
|
| GraphQLInputObjectType.Builder |
|
| GraphQLInputSchemaElement |
A schema element that is concerned with input.
|
| GraphQLInputType |
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. |
| GraphQLInputValueDefinition |
Named schema elements that contain input type information.
|
| GraphqlIntCoercing |
The deprecated methods still have implementations in case code outside graphql-java is calling them
but internally the call paths have been replaced.
|
| GraphQLInterfaceType |
In graphql, an interface is an abstract type that defines the set of fields that a type must include to
implement that interface.
|
| GraphQLInterfaceType.Builder |
|
| GraphqlLexer |
|
| 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.
|
| GraphqlListener |
This interface defines a complete listener for a parse tree produced by
GraphqlParser. |
| GraphQLModifiedType |
A modified type wraps another graphql type and modifies it behavior
|
| GraphQLNamedInputType |
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. |
| GraphQLNamedOutputType |
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. |
| GraphQLNamedSchemaElement |
A Schema element which has a name and also a description and AST Node which it is based on.
|
| GraphQLNamedType |
A GraphQLType which is also a named element, which means it has a getName() method.
|
| GraphQLNonNull |
A modified type that indicates there the underlying wrapped type will not be null.
|
| GraphQLNullableType |
|
| 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.
|
| GraphQLObjectType.Builder |
|
| GraphQLOutputType |
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. |
| GraphqlParser |
|
| GraphqlParser.AliasContext |
|
| GraphqlParser.ArgumentContext |
|
| GraphqlParser.ArgumentsContext |
|
| GraphqlParser.ArgumentsDefinitionContext |
|
| GraphqlParser.ArrayValueContext |
|
| GraphqlParser.ArrayValueWithVariableContext |
|
| GraphqlParser.BaseNameContext |
|
| GraphqlParser.DefaultValueContext |
|
| GraphqlParser.DefinitionContext |
|
| GraphqlParser.DescriptionContext |
|
| GraphqlParser.DirectiveContext |
|
| GraphqlParser.DirectiveDefinitionContext |
|
| GraphqlParser.DirectiveLocationContext |
|
| GraphqlParser.DirectiveLocationsContext |
|
| GraphqlParser.DirectivesContext |
|
| GraphqlParser.DocumentContext |
|
| GraphqlParser.EmptyParenthesesContext |
|
| GraphqlParser.EnumTypeDefinitionContext |
|
| GraphqlParser.EnumTypeExtensionDefinitionContext |
|
| GraphqlParser.EnumValueContext |
|
| GraphqlParser.EnumValueDefinitionContext |
|
| GraphqlParser.EnumValueDefinitionsContext |
|
| GraphqlParser.EnumValueNameContext |
|
| GraphqlParser.ExtensionEnumValueDefinitionsContext |
|
| GraphqlParser.ExtensionFieldsDefinitionContext |
|
| GraphqlParser.ExtensionInputObjectValueDefinitionsContext |
|
| GraphqlParser.FieldContext |
|
| GraphqlParser.FieldDefinitionContext |
|
| GraphqlParser.FieldsDefinitionContext |
|
| GraphqlParser.FragmentDefinitionContext |
|
| GraphqlParser.FragmentNameContext |
|
| GraphqlParser.FragmentSpreadContext |
|
| GraphqlParser.ImplementsInterfacesContext |
|
| GraphqlParser.InlineFragmentContext |
|
| GraphqlParser.InputObjectTypeDefinitionContext |
|
| GraphqlParser.InputObjectTypeExtensionDefinitionContext |
|
| GraphqlParser.InputObjectValueDefinitionsContext |
|
| GraphqlParser.InputValueDefinitionContext |
|
| GraphqlParser.InterfaceTypeDefinitionContext |
|
| GraphqlParser.InterfaceTypeExtensionDefinitionContext |
|
| GraphqlParser.ListTypeContext |
|
| GraphqlParser.NameContext |
|
| GraphqlParser.NonNullTypeContext |
|
| GraphqlParser.ObjectFieldContext |
|
| GraphqlParser.ObjectFieldWithVariableContext |
|
| GraphqlParser.ObjectTypeDefinitionContext |
|
| GraphqlParser.ObjectTypeExtensionDefinitionContext |
|
| GraphqlParser.ObjectValueContext |
|
| GraphqlParser.ObjectValueWithVariableContext |
|
| GraphqlParser.OperationDefinitionContext |
|
| GraphqlParser.OperationTypeContext |
|
| GraphqlParser.OperationTypeDefinitionContext |
|
| GraphqlParser.ScalarTypeDefinitionContext |
|
| GraphqlParser.ScalarTypeExtensionDefinitionContext |
|
| GraphqlParser.SchemaDefinitionContext |
|
| GraphqlParser.SchemaExtensionContext |
|
| GraphqlParser.SelectionContext |
|
| GraphqlParser.SelectionSetContext |
|
| GraphqlParser.TypeConditionContext |
|
| GraphqlParser.TypeContext |
|
| GraphqlParser.TypeDefinitionContext |
|
| GraphqlParser.TypeExtensionContext |
|
| GraphqlParser.TypeNameContext |
|
| GraphqlParser.TypeSystemDefinitionContext |
|
| GraphqlParser.TypeSystemExtensionContext |
|
| GraphqlParser.UnionMembersContext |
|
| GraphqlParser.UnionMembershipContext |
|
| GraphqlParser.UnionTypeDefinitionContext |
|
| GraphqlParser.UnionTypeExtensionDefinitionContext |
|
| GraphqlParser.ValueContext |
|
| GraphqlParser.ValueWithVariableContext |
|
| GraphqlParser.VariableContext |
|
| GraphqlParser.VariableDefinitionContext |
|
| GraphqlParser.VariableDefinitionsContext |
|
| GraphQLScalarType |
A scalar type is a leaf node in the graphql tree of types.
|
| GraphQLScalarType.Builder |
|
| GraphQLSchema |
The schema represents the combined type system of the graphql engine.
|
| GraphQLSchema.Builder |
|
| GraphQLSchema.BuilderWithoutTypes |
|
| GraphQLSchemaElement |
A GraphQLSchema can be viewed as a graph of GraphQLSchemaElement.
|
| GraphQLSchemaElementAdapter |
|
| GraphQLSchemaTraversalControl |
|
| GraphQLSchemaTraversalControl.Control |
|
| GraphQLSchemaVisitor |
This visitor interface offers more "smarts" above GraphQLTypeVisitor and aims to be easier to use
with more type safe helpers. |
| GraphQLSchemaVisitor.AppliedDirectiveArgumentVisitorEnvironment |
|
| GraphQLSchemaVisitor.AppliedDirectiveVisitorEnvironment |
|
| GraphQLSchemaVisitor.ArgumentVisitorEnvironment |
|
| GraphQLSchemaVisitor.DirectiveVisitorEnvironment |
|
| GraphQLSchemaVisitor.EnumTypeVisitorEnvironment |
|
| GraphQLSchemaVisitor.EnumValueDefinitionVisitorEnvironment |
|
| GraphQLSchemaVisitor.FieldDefinitionVisitorEnvironment |
|
| GraphQLSchemaVisitor.InputObjectFieldVisitorEnvironment |
|
| GraphQLSchemaVisitor.InputObjectTypeVisitorEnvironment |
|
| GraphQLSchemaVisitor.InterfaceTypeVisitorEnvironment |
|
| GraphQLSchemaVisitor.ObjectVisitorEnvironment |
|
| GraphQLSchemaVisitor.ScalarTypeVisitorEnvironment |
|
| GraphQLSchemaVisitor.SchemaElementVisitorEnvironment |
|
| GraphQLSchemaVisitor.UnionTypeVisitorEnvironment |
|
| GraphQLSchemaVisitorAdapter |
|
| GraphQLSchemaVisitorAdapter.AppliedDirectiveArgumentEnv |
|
| GraphQLSchemaVisitorAdapter.AppliedDirectiveEnv |
|
| GraphQLSchemaVisitorAdapter.ArgumentEnv |
|
| GraphQLSchemaVisitorAdapter.DirectiveEnv |
|
| GraphQLSchemaVisitorAdapter.EnumTypeEnv |
|
| GraphQLSchemaVisitorAdapter.EnumValueDefinitionEnv |
|
| GraphQLSchemaVisitorAdapter.FieldDefinitionEnv |
|
| GraphQLSchemaVisitorAdapter.InputObjectFieldEnv |
|
| GraphQLSchemaVisitorAdapter.InputObjectTypeEnv |
|
| GraphQLSchemaVisitorAdapter.InterfaceTypeEnv |
|
| GraphQLSchemaVisitorAdapter.ObjectEnv |
|
| GraphQLSchemaVisitorAdapter.ScalarTypeEnv |
|
| GraphQLSchemaVisitorAdapter.SchemaElementEnv |
|
| GraphQLSchemaVisitorAdapter.UnionTypeEnv |
|
| GraphQLSchemaVisitorEnvironment<T extends GraphQLSchemaElement> |
|
| GraphQLSchemaVisitorEnvironmentImpl<T extends GraphQLSchemaElement> |
|
| GraphqlStringCoercing |
The deprecated methods still have implementations in case code outside graphql-java is calling them
but internally the call paths have been replaced.
|
| GraphQLType |
A type inside the GraphQLSchema.
|
| GraphqlTypeBuilder<B extends GraphqlTypeBuilder<B>> |
|
| GraphQLTypeCollectingVisitor |
|
| GraphqlTypeComparatorEnvironment |
Defines the scope to control where the registered Comparator can be applied.
|
| GraphqlTypeComparatorEnvironment.Builder |
|
| GraphqlTypeComparatorRegistry |
|
| GraphqlTypeComparators |
|
| GraphQLTypeReference |
A special type to allow a object/interface types to reference itself.
|
| GraphQLTypeResolvingVisitor |
|
| GraphQLTypeResolvingVisitor.TypeRefResolvingVisitor |
|
| GraphQLTypeUtil |
|
| GraphQLTypeVisitor |
GraphQLTypeVisitor can be used to visit all the elements of a schema
(types, fields, directives and so on) in a visitor pattern.
|
| GraphQLTypeVisitorStub |
|
| GraphQLUnionType |
A union type is a polymorphic type that dynamically represents one of more concrete object types.
|
| GraphQLUnionType.Builder |
|
| GraphQLUnmodifiedType |
|
| HungarianAlgorithm |
An implementation of the Hungarian algorithm for solving the assignment
problem.
|
| I18n |
|
| I18n.BundleType |
This enum is a type safe way to control what resource bundle to load from
|
| I18nMsg |
A class that represents the intention to create a I18n message
|
| IgnoredChar |
Graphql syntax has a series of characters, such as spaces, new lines and commas that are not considered relevant
to the syntax.
|
| IgnoredChar.IgnoredCharKind |
|
| IgnoredChars |
Graphql syntax has a series of characters, such as spaces, new lines and commas that are not considered relevant
to the syntax.
|
| IllegalNameError |
|
| ImmutableKit |
|
| ImmutableMapWithNullValues<K,V> |
The standard ImmutableMap does not allow null values.
|
| ImplementingTypeDefinition<T extends TypeDefinition> |
|
| ImplementingTypesChecker |
A support class to help break up the large SchemaTypeChecker class.
|
| InlineFragment |
|
| InlineFragment.Builder |
|
| InMemoryPersistedQueryCache |
A PersistedQueryCache that is just an in memory map of known queries.
|
| InMemoryPersistedQueryCache.Builder |
|
| InputAndOutputTypesUsedAppropriately |
Schema validation rule ensuring no input type forms an unbroken non-nullable recursion,
as such a type would be impossible to satisfy
|
| InputInterceptor |
This INTERNAL class can be used to intercept input values before they are coerced into runtime values
by the ValuesResolver code. |
| 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.
|
| InputObjectTypeDefinition |
|
| InputObjectTypeDefinition.Builder |
|
| InputObjectTypeExtensionDefinition |
|
| InputObjectTypeExtensionDefinition.Builder |
|
| InputValueDefinition |
|
| InputValueDefinition.Builder |
|
| InputValueWithState |
|
| InputValueWithState.State |
|
| Instrumentation |
Provides the capability to instrument the execution steps of a GraphQL query.
|
| InstrumentationContext<T> |
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. |
| InstrumentationCreateStateParameters |
|
| InstrumentationExecuteOperationParameters |
|
| InstrumentationExecutionParameters |
|
| InstrumentationExecutionStrategyParameters |
|
| InstrumentationFieldCompleteParameters |
|
| InstrumentationFieldFetchParameters |
|
| InstrumentationFieldParameters |
|
| InstrumentationState |
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 |
| InstrumentationValidationParameters |
|
| InterfaceFieldArgumentNotOptionalError |
|
| InterfaceFieldArgumentRedefinitionError |
|
| InterfaceFieldRedefinitionError |
|
| InterfaceImplementedMoreThanOnceError |
|
| InterfaceImplementingItselfError |
|
| InterfaceTypeDefinition |
|
| InterfaceTypeDefinition.Builder |
|
| InterfaceTypeExtensionDefinition |
|
| InterfaceTypeExtensionDefinition.Builder |
|
| InterfaceWiringEnvironment |
|
| InterfaceWithCircularImplementationHierarchyError |
|
| Internal |
This represents code that the graphql-java project considers internal code that MAY not be stable within
major releases.
|
| InterThreadMemoizedSupplier<T> |
This memoizing supplier DOES use locked double locking to set its value.
|
| IntraThreadMemoizedSupplier<T> |
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.
|
| Introspection |
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. |
| Introspection.DirectiveLocation |
|
| Introspection.TypeKind |
|
| IntrospectionDataFetcher<T> |
|
| IntrospectionDataFetchingEnvironment |
|
| IntrospectionDisabledError |
|
| IntrospectionQuery |
|
| IntrospectionQueryBuilder |
|
| IntrospectionQueryBuilder.Options |
|
| IntrospectionResultToSchema |
|
| IntrospectionWithDirectivesSupport |
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.
|
| IntrospectionWithDirectivesSupport.DirectivePredicate |
A callback which allows you to decide what directives may be included
in introspection extensions
|
| IntrospectionWithDirectivesSupport.DirectivePredicateEnvironment |
|
| IntValue |
|
| IntValue.Builder |
|
| InvalidCursorException |
|
| InvalidPageSizeException |
|
| InvalidSchemaException |
|
| InvalidSyntaxError |
|
| InvalidSyntaxException |
This exception is thrown by the Parser if the graphql syntax is not valid |
| InvalidUnicodeSyntaxException |
|
| KnownArgumentNames |
|
| KnownDirectives |
|
| KnownFragmentNames |
|
| KnownTypeNames |
|
| LambdaFetchingSupport |
|
| LanguageTraversal |
|
| LegacyCoercingInputInterceptor |
|
| LevelMap |
This data structure tracks the number of expected calls on a given level
|
| LightDataFetcher<T> |
|
| ListType |
|
| ListType.Builder |
|
| LockKit |
This provides reentrant locking support for our code base.
|
| LockKit.ComputedOnce |
Will allow for lazy computation of some values just once
|
| LockKit.ReentrantLock |
A class to run code inside a reentrant lock
|
| LogKit |
|
| LoneAnonymousOperation |
|
| MapEnumValuesProvider |
|
| Mapping |
A mapping (in the math sense) from a list of vertices to another list of
vertices.
|
| MaxQueryComplexityInstrumentation |
Prevents execution if the query complexity is greater than the specified maxComplexity.
|
| MaxQueryComplexityInstrumentation.State |
|
| MaxQueryDepthInstrumentation |
Prevents execution if the query depth is greater than the specified maxDepth.
|
| MergedField |
This represents all Fields in a query which overlap and are merged into one.
|
| MergedField.Builder |
|
| MergedSelectionSet |
|
| MergedSelectionSet.Builder |
|
| MissingInterfaceFieldArgumentsError |
|
| MissingInterfaceFieldError |
|
| MissingInterfaceTypeError |
|
| MissingRootTypeException |
This is thrown if a query is attempting to perform an operation not defined in the GraphQL schema
|
| MissingScalarImplementationError |
|
| MissingTransitiveInterfaceError |
|
| MissingTypeError |
|
| MissingTypeResolverError |
|
| MockedWiringFactory |
|
| MoreTokensSyntaxException |
|
| MultiReadOnlyGraphQLTypeVisitor |
|
| 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.
|
| MultiSourceReader.Builder |
|
| MultiSourceReader.SourceAndLine |
|
| MultiSourceReader.SourcePart |
|
| Mutable |
This marks a type as mutable which means after constructing it can be changed.
|
| MutableRef<T> |
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.
|
| NamedNode<T extends NamedNode> |
Represents a language node that has a name
|
| NaturalEnumValuesProvider<T extends java.lang.Enum<T>> |
Simple EnumValuesProvided which maps the GraphQL Enum name to the Java Enum instance.
|
| NoContextChainedInstrumentation |
|
| 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.
|
| NodeAdapter<T> |
Adapts an arbitrary class to behave as a node.
|
| NodeBuilder |
|
| NodeChildrenContainer |
Container of children of a Node. |
| NodeChildrenContainer.Builder |
|
| NodeDirectivesBuilder |
|
| NodeLocation |
General position of a Node inside a parent.
|
| NodeMultiZipper<T> |
|
| NodeParentTree<T extends Node> |
This represents a hierarchy from a graphql language node upwards to its
associated parent nodes.
|
| NodeToRuleCapturingParser |
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).
|
| NodeToRuleCapturingParser.ParserContext |
|
| NodeTraverser |
Lets you traverse a Node tree. |
| NodeUtil |
Helper class for working with Nodes |
| NodeUtil.GetOperationResult |
|
| NodeVisitor |
|
| NodeVisitorStub |
Convenient implementation of NodeVisitor for easy subclassing methods handling different types of Nodes in one method. |
| NodeVisitorWithTypeTracking |
Internally used node visitor which delegates to a QueryVisitor with type
information about the visited field. |
| NodeZipper<T> |
|
| NodeZipper.ModificationType |
|
| NoFragmentCycles |
|
| NoIntrospectionGraphqlFieldVisibility |
Deprecated.
|
| NonBlockingMutexExecutor |
Executor that provides mutual exclusion between the operations submitted to it,
without blocking.
|
| NonBlockingMutexExecutor.RunNode |
|
| NonNullableFieldValidator |
|
| NonNullableFieldWasNullError |
This is the base error that indicates that a non null field value was in fact null.
|
| NonNullableFieldWasNullException |
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
|
| NonNullableValueCoercedAsNullException |
This is thrown if a non nullable value is coerced to a null value
|
| NonNullType |
|
| NonNullType.Builder |
|
| NonSDLDefinitionError |
|
| NonUniqueArgumentError |
|
| NonUniqueDirectiveError |
|
| NonUniqueNameError |
|
| NoOpPreparsedDocumentProvider |
|
| NoopWiringFactory |
|
| NormalizedInputValue |
An argument value with type information.
|
| NotAnInputTypeError |
|
| NotAnOutputTypeError |
|
| NoUnbrokenInputCycles |
Schema validation rule ensuring no input type forms an unbroken non-nullable recursion,
as such a type would be impossible to satisfy
|
| NoUndefinedVariables |
|
| NoUnusedFragments |
|
| NoUnusedVariables |
|
| NullValue |
|
| NullValue.Builder |
|
| ObjectField |
|
| ObjectField.Builder |
|
| ObjectTypeDefinition |
|
| ObjectTypeDefinition.Builder |
|
| ObjectTypeExtensionDefinition |
|
| ObjectTypeExtensionDefinition.Builder |
|
| ObjectValue |
|
| ObjectValue.Builder |
|
| OneOfInputObjectRules |
|
| OneOfNullValueException |
The input map to One Of Input Types MUST only have 1 entry with a non null value
|
| OneOfTooManyKeysException |
The input map to One Of Input Types MUST only have 1 entry
|
| OperationDefinition |
|
| OperationDefinition.Builder |
|
| OperationDefinition.Operation |
|
| OperationRedefinitionError |
|
| OperationTypeDefinition |
|
| OperationTypeDefinition.Builder |
|
| OperationTypesMustBeObjects |
|
| OverlappingFieldsCanBeMerged |
|
| OverlappingFieldsCanBeMerged.Conflict |
|
| OverlappingFieldsCanBeMerged.FieldAndType |
|
| PageInfo |
|
| Pair<T,U> |
|
| ParseAndValidate |
This class allows you to parse and validate a graphql query without executing it.
|
| ParseAndValidateResult |
A result object used in ParseAndValidate helper that indicates the outcomes of a parse
and validate operation. |
| ParseAndValidateResult.Builder |
|
| ParseCancelledException |
|
| ParseCancelledTooDeepException |
|
| ParseCancelledTooManyCharsException |
|
| Parser |
This can parse graphql syntax, both Query syntax and Schema Definition Language (SDL) syntax, into an
Abstract Syntax Tree (AST) represented by a Document |
| ParserEnvironment |
This is the arguments that can be passed to a Parser |
| ParserEnvironment.Builder |
|
| ParserOptions |
Options that control how the Parser behaves. |
| ParserOptions.Builder |
|
| ParsingListener |
This listener interface is invoked for each token parsed by the graphql parser code.
|
| ParsingListener.Token |
This represents a token that has been parsed
|
| PersistedQueryCache |
This interface is used to abstract an actual cache that can cache parsed persistent queries.
|
| PersistedQueryCacheMiss |
The call back when a valid persisted query is not in cache and it needs to be compiled and validated
by the graphql engine.
|
| PersistedQueryError |
|
| PersistedQueryIdInvalid |
|
| PersistedQueryNotFound |
An exception that indicates the query id is not valid and can be found ever in cache
|
| PersistedQuerySupport |
This abstract class forms the basis for persistent query support.
|
| PossibleFragmentSpreads |
|
| PossibleMappingsCalculator |
We don't want to allow arbitrary schema changes.
|
| PossibleMappingsCalculator.VertexContextSegment |
|
| PreparsedDocumentEntry |
An instance of a preparsed document entry represents the result of a query parse and validation.
|
| PreparsedDocumentProvider |
Interface that allows clients to hook in Document caching and/or the whitelisting of queries.
|
| PrettyAstPrinter |
A printer that acts as a code formatter.
|
| PrettyAstPrinter.PrettyPrinterOptions |
Contains options that modify how a document is printed.
|
| PrettyAstPrinter.PrettyPrinterOptions.Builder |
|
| PrettyAstPrinter.PrettyPrinterOptions.IndentType |
|
| PrintStreamReporter |
A reporter that prints its output to a PrintStream
|
| PropertyDataFetcher<T> |
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.
|
| PropertyDataFetcherHelper |
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
|
| PropertyFetchingImpl |
A re-usable class that can fetch from POJOs
|
| PropertyFetchingImpl.CachedLambdaFunction |
|
| PropertyFetchingImpl.CacheKey |
|
| PropertyFetchingImpl.FastNoSuchMethodException |
|
| PropertyFetchingImpl.MethodFinder |
|
| ProvidedNonNullArguments |
|
| PublicApi |
This represents code that the graphql-java project considers public API and has an imperative to be stable within
major releases.
|
| PublicSpi |
This represents code that the graphql-java project considers public SPI and has an imperative to be stable within
major releases.
|
| QueryAppliedDirective |
An applied directive represents the instance of a directive that is applied to a query element such as a field or fragment.
|
| QueryAppliedDirective.Builder |
|
| QueryAppliedDirectiveArgument |
|
| QueryAppliedDirectiveArgument.Builder |
|
| QueryComplexityCalculator |
|
| QueryComplexityCalculator.Builder |
|
| QueryComplexityInfo |
The query complexity info.
|
| QueryComplexityInfo.Builder |
|
| QueryDepthInfo |
The query depth info.
|
| QueryDepthInfo.Builder |
|
| QueryDirectives |
This gives you access to the immediate directives on a MergedField. |
| QueryDirectives.Builder |
|
| QueryDirectivesBuilder |
|
| QueryDirectivesImpl |
These objects are ALWAYS in the context of a single MergedField
|
| QueryOperationMissingError |
|
| QueryReducer<T> |
Used by QueryTraverser to reduce the fields of a Document (or part of it) to a single value. |
| QueryTransformer |
Helps to transform a Document (or parts of it) and tracks at the same time the corresponding Schema types.
|
| QueryTransformer.Builder |
|
| QueryTraversalContext |
QueryTraverser helper class that maintains traversal context as
the query traversal algorithm traverses down the Selection AST
|
| QueryTraverser |
Helps to traverse (or reduce) a Document (or parts of it) and tracks at the same time the corresponding Schema types.
|
| QueryTraverser.Builder |
|
| QueryVisitor |
|
| QueryVisitorFieldArgumentEnvironment |
|
| QueryVisitorFieldArgumentEnvironmentImpl |
|
| QueryVisitorFieldArgumentInputValue |
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.
|
| QueryVisitorFieldArgumentInputValueImpl |
|
| QueryVisitorFieldArgumentValueEnvironment |
|
| QueryVisitorFieldArgumentValueEnvironmentImpl |
|
| QueryVisitorFieldEnvironment |
|
| QueryVisitorFieldEnvironmentImpl |
|
| QueryVisitorFragmentDefinitionEnvironment |
|
| QueryVisitorFragmentDefinitionEnvironmentImpl |
|
| QueryVisitorFragmentSpreadEnvironment |
|
| QueryVisitorFragmentSpreadEnvironmentImpl |
|
| QueryVisitorInlineFragmentEnvironment |
|
| QueryVisitorInlineFragmentEnvironmentImpl |
|
| QueryVisitorStub |
|
| RawVariables |
|
| Relay |
This can be used to compose graphql runtime types that implement
that Relay specification.
|
| Relay.ResolvedGlobalId |
|
| ReplaceNode |
|
| ResolveType |
|
| ResultNodesInfo |
This class is used to track the number of result nodes that have been created during execution.
|
| ResultPath |
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.
|
| RulesVisitor |
|
| RuntimeWiring |
A runtime wiring is a specification of data fetchers, type resolvers and custom scalars that are needed
to wire together a functional GraphQLSchema |
| RuntimeWiring.Builder |
|
| SafeTokenReader |
This reader will only emit a maximum number of characters from it.
|
| SafeTokenSource |
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.
|
| ScalarInfo |
Info on all the standard scalar objects provided by graphql-java
|
| ScalarLeaves |
|
| Scalars |
This contains the implementations of the Scalar types that ship with graphql-java.
|
| ScalarTypeDefinition |
|
| ScalarTypeDefinition.Builder |
|
| ScalarTypeExtensionDefinition |
|
| ScalarTypeExtensionDefinition.Builder |
|
| ScalarValue<T extends Value> |
|
| ScalarWiringEnvironment |
|
| SchemaDefinition |
|
| SchemaDefinition.Builder |
|
| SchemaDiff |
The SchemaDiff is called with a DiffSet and will report the
differences in the graphql schema APIs by raising events to a
DifferenceReporter |
| SchemaDiff.CountingReporter |
|
| SchemaDiff.Options |
Options for controlling the diffing process
|
| SchemaDifference |
Any kind of difference between two schemas is a SchemaDifference.
|
| SchemaDifference.AppliedDirectiveAddition |
|
| SchemaDifference.AppliedDirectiveArgumentAddition |
|
| SchemaDifference.AppliedDirectiveArgumentDeletion |
|
| SchemaDifference.AppliedDirectiveArgumentRename |
|
| SchemaDifference.AppliedDirectiveArgumentValueModification |
|
| SchemaDifference.AppliedDirectiveDeletion |
|
| SchemaDifference.AppliedDirectiveDifference |
|
| SchemaDifference.AppliedDirectiveDirectiveArgumentLocation |
|
| SchemaDifference.AppliedDirectiveEnumLocation |
|
| SchemaDifference.AppliedDirectiveEnumValueLocation |
|
| SchemaDifference.AppliedDirectiveInputObjectFieldLocation |
|
| SchemaDifference.AppliedDirectiveInputObjectLocation |
|
| SchemaDifference.AppliedDirectiveInterfaceFieldArgumentLocation |
|
| SchemaDifference.AppliedDirectiveInterfaceFieldLocation |
|
| SchemaDifference.AppliedDirectiveInterfaceLocation |
|
| SchemaDifference.AppliedDirectiveLocationDetail |
SCHEMA,
SCALAR,
OBJECT,
FIELD_DEFINITION,
ARGUMENT_DEFINITION,
INTERFACE,
UNION,
ENUM,
ENUM_VALUE,
INPUT_OBJECT,
INPUT_FIELD_DEFINITION
|
| SchemaDifference.AppliedDirectiveObjectFieldArgumentLocation |
|
| SchemaDifference.AppliedDirectiveObjectFieldLocation |
|
| SchemaDifference.AppliedDirectiveObjectLocation |
|
| SchemaDifference.AppliedDirectiveRenamed |
|
| SchemaDifference.AppliedDirectiveScalarLocation |
|
| SchemaDifference.AppliedDirectiveSchemaLocation |
|
| SchemaDifference.AppliedDirectiveUnionLocation |
|
| SchemaDifference.DirectiveAddition |
|
| SchemaDifference.DirectiveArgumentAddition |
|
| SchemaDifference.DirectiveArgumentDefaultValueModification |
|
| SchemaDifference.DirectiveArgumentDeletion |
|
| SchemaDifference.DirectiveArgumentRename |
|
| SchemaDifference.DirectiveArgumentTypeModification |
|
| SchemaDifference.DirectiveDeletion |
|
| SchemaDifference.DirectiveDifference |
|
| SchemaDifference.DirectiveModification |
|
| SchemaDifference.DirectiveModificationDetail |
|
| SchemaDifference.EnumAddition |
|
| SchemaDifference.EnumDeletion |
|
| SchemaDifference.EnumDifference |
|
| SchemaDifference.EnumModification |
|
| SchemaDifference.EnumModificationDetail |
|
| SchemaDifference.EnumValueAddition |
|
| SchemaDifference.EnumValueDeletion |
|
| SchemaDifference.EnumValueRenamed |
|
| SchemaDifference.InputObjectAddition |
|
| SchemaDifference.InputObjectDeletion |
|
| SchemaDifference.InputObjectDifference |
|
| SchemaDifference.InputObjectFieldAddition |
|
| SchemaDifference.InputObjectFieldDefaultValueModification |
|
| SchemaDifference.InputObjectFieldDeletion |
|
| SchemaDifference.InputObjectFieldRename |
|
| SchemaDifference.InputObjectFieldTypeModification |
|
| SchemaDifference.InputObjectModification |
|
| SchemaDifference.InputObjectModificationDetail |
|
| SchemaDifference.InterfaceAddition |
|
| SchemaDifference.InterfaceDeletion |
|
| SchemaDifference.InterfaceDifference |
|
| SchemaDifference.InterfaceFieldAddition |
|
| SchemaDifference.InterfaceFieldArgumentAddition |
|
| SchemaDifference.InterfaceFieldArgumentDefaultValueModification |
|
| SchemaDifference.InterfaceFieldArgumentDeletion |
|
| SchemaDifference.InterfaceFieldArgumentRename |
|
| SchemaDifference.InterfaceFieldArgumentTypeModification |
|
| SchemaDifference.InterfaceFieldDeletion |
|
| SchemaDifference.InterfaceFieldRename |
|
| SchemaDifference.InterfaceFieldTypeModification |
|
| SchemaDifference.InterfaceInterfaceImplementationAddition |
|
| SchemaDifference.InterfaceInterfaceImplementationDeletion |
|
| SchemaDifference.InterfaceModification |
|
| SchemaDifference.InterfaceModificationDetail |
|
| SchemaDifference.ObjectAddition |
|
| SchemaDifference.ObjectDeletion |
|
| SchemaDifference.ObjectDifference |
|
| SchemaDifference.ObjectFieldAddition |
|
| SchemaDifference.ObjectFieldArgumentAddition |
|
| SchemaDifference.ObjectFieldArgumentDefaultValueModification |
|
| SchemaDifference.ObjectFieldArgumentDeletion |
|
| SchemaDifference.ObjectFieldArgumentRename |
|
| SchemaDifference.ObjectFieldArgumentTypeModification |
|
| SchemaDifference.ObjectFieldDeletion |
|
| SchemaDifference.ObjectFieldRename |
|
| SchemaDifference.ObjectFieldTypeModification |
|
| SchemaDifference.ObjectInterfaceImplementationAddition |
|
| SchemaDifference.ObjectInterfaceImplementationDeletion |
|
| SchemaDifference.ObjectModification |
|
| SchemaDifference.ObjectModificationDetail |
|
| SchemaDifference.ScalarAddition |
|
| SchemaDifference.ScalarDeletion |
|
| SchemaDifference.ScalarDifference |
|
| SchemaDifference.ScalarModification |
|
| SchemaDifference.ScalarModificationDetail |
|
| SchemaDifference.SchemaAddition |
|
| SchemaDifference.SchemaDeletion |
|
| SchemaDifference.SchemaModification |
|
| SchemaDifference.SchemaModificationDetail |
|
| SchemaDifference.UnionAddition |
|
| SchemaDifference.UnionDeletion |
|
| SchemaDifference.UnionDifference |
|
| SchemaDifference.UnionMemberAddition |
|
| SchemaDifference.UnionMemberDeletion |
|
| SchemaDifference.UnionModification |
|
| SchemaDifference.UnionModificationDetail |
|
| SchemaDiffing |
|
| SchemaDiffingCancelledException |
|
| SchemaDiffingRunningCheck |
|
| SchemaDiffSet |
Interface used to define 2 schemas that can be diffed by the SchemaDiff operation. |
| SchemaDirectiveWiring |
A SchemaDirectiveWiring is responsible for enhancing a runtime element based on directives placed on that
element in the Schema Definition Language (SDL).
|
| SchemaDirectiveWiringEnvironment<T extends GraphQLDirectiveContainer> |
|
| SchemaDirectiveWiringEnvironmentImpl<T extends GraphQLDirectiveContainer> |
|
| SchemaDirectiveWiringSchemaGeneratorPostProcessing |
|
| SchemaElementChildrenContainer |
|
| SchemaElementChildrenContainer.Builder |
|
| SchemaExtensionDefinition |
|
| SchemaExtensionDefinition.Builder |
|
| SchemaExtensionsChecker |
|
| SchemaGenerator |
This can generate a working runtime schema from a type registry and runtime wiring
|
| SchemaGenerator.Options |
These options control how the schema generation works
|
| SchemaGeneratorAppliedDirectiveHelper |
This contains helper code to build out appliedm directives on schema element
|
| SchemaGeneratorDirectiveHelper |
This contains the helper code that allows SchemaDirectiveWiring implementations
to be invoked during schema generation. |
| SchemaGeneratorDirectiveHelper.EnvBuilder<T extends GraphQLDirectiveContainer> |
|
| SchemaGeneratorDirectiveHelper.EnvInvoker<T extends GraphQLDirectiveContainer> |
|
| SchemaGeneratorDirectiveHelper.Parameters |
|
| SchemaGeneratorHelper |
|
| SchemaGeneratorHelper.BuildContext |
We pass this around so we know what we have defined in a stack like manner plus
it gives us helper functions
|
| SchemaGeneratorPostProcessing |
Deprecated.
|
| SchemaGraph |
|
| SchemaGraphFactory |
|
| SchemaMissingError |
|
| SchemaParseOrder |
|
| SchemaParser |
|
| SchemaPrinter |
This can print an in memory GraphQL schema back to a logical schema definition
|
| SchemaPrinter.Options |
Options to use when printing a schema
|
| SchemaPrinter.SchemaElementPrinter<T> |
|
| SchemaProblem |
|
| SchemaRedefinitionError |
|
| SchemaTransformer |
Transforms a GraphQLSchema object by calling bac on a provided visitor. |
| SchemaTransformer.DummyRoot |
|
| SchemaTransformer.RelevantZippersAndBreadcrumbs |
|
| SchemaTransformer.ZipperWithOneParent |
|
| SchemaTraverser |
|
| SchemaTraverser.TraverserDelegateListVisitor |
|
| SchemaTraverser.TraverserDelegateVisitor |
|
| SchemaTypeChecker |
This helps pre check the state of the type system to ensure it can be made into an executable schema.
|
| SchemaTypeDirectivesChecker |
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
|
| SchemaTypeExtensionsChecker |
A support class to help break up the large SchemaTypeChecker class.
|
| SchemaUsage |
This class shows schema usage information.
|
| SchemaUsage.Builder |
|
| SchemaUsageSupport |
|
| SchemaUtil |
|
| SchemaValidationError |
|
| SchemaValidationErrorClassification |
Error in graphql schema validation can have a classification,
and all the error classifications implement this interface.
|
| SchemaValidationErrorCollector |
|
| SchemaValidationErrorType |
|
| SchemaValidator |
|
| SDLDefinition<T extends SDLDefinition> |
An interface for Schema Definition Language (SDL) definitions.
|
| SDLExtensionDefinition |
A marker interface for Schema Definition Language (SDL) extension definitions.
|
| SDLNamedDefinition<T extends SDLNamedDefinition> |
A interface for named Schema Definition Language (SDL) definition.
|
| SelectedField |
|
| Selection<T extends Selection<T>> |
|
| SelectionSet |
|
| SelectionSet.Builder |
|
| SelectionSetContainer<T extends Node> |
|
| SerializationError |
|
| SimpleDataFetcherExceptionHandler |
|
| 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.
|
| SimpleInstrumentation |
Deprecated.
|
| SimpleInstrumentationContext<T> |
|
| SimpleListConnection<T> |
|
| SimplePerformantInstrumentation |
|
| SingleSubscriberPublisher<T> |
A Publisher of things that are buffered and handles a single subscriber at a time.
|
| SingleSubscriberPublisher.OnSubscriptionCallback |
This is called when a subscription is made to the publisher
|
| SourceLocation |
|
| StaticDataFetcher |
|
| StringValue |
|
| StringValue.Builder |
|
| StringValueParsing |
Contains parsing code for the StringValue types in the grammar
|
| StronglyConnectedComponentsTopologicallySorted |
This class returns a list of strongly connected components (SCC) which are topologically sorted.
|
| SubscriptionExecutionStrategy |
An execution strategy that implements graphql subscriptions by using reactive-streams
as the output result of the subscription query.
|
| SubscriptionPublisher |
Subscription queries return an instance of this class in the ExecutionResult data element
for the subscribed field. |
| SubscriptionUniqueRootField |
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
|
| ThreadSafe |
This represents code that is known to be mutable but thread safe.
|
| TracingInstrumentation |
|
| TracingInstrumentation.Options |
|
| TracingSupport |
This creates a map of tracing information as outlined in https://github.com/apollographql/apollo-tracing
|
| TracingSupport.TracingContext |
|
| TraversalContext |
|
| TraversalControl |
Special traversal control values
|
| Traverser<T> |
|
| TraverserContext<T> |
Traversal context.
|
| TraverserContext.Phase |
|
| TraverserResult |
|
| TraverserState<T> |
|
| TraverserState.EndList<U> |
|
| TraverserState.QueueTraverserState<U> |
|
| TraverserState.StackTraverserState<U> |
|
| TraverserVisitor<T> |
|
| TraverserVisitorStub<T> |
|
| TreeParallelTransformer<T> |
|
| TreeParallelTraverser<T> |
|
| TreeTransformer<T> |
|
| TreeTransformerUtil |
|
| TrivialDataFetcher<T> |
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.
|
| Type<T extends Type> |
|
| TypeAndFieldRule |
The validation about GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType.
|
| TypeDefinition<T extends TypeDefinition> |
An interface for type definitions in a Schema Definition Language (SDL).
|
| TypeDefinitionRegistry |
|
| TypeExtensionDirectiveRedefinitionError |
|
| TypeExtensionEnumValueRedefinitionError |
|
| TypeExtensionFieldRedefinitionError |
|
| TypeExtensionMissingBaseTypeError |
|
| TypeFromAST |
|
| TypeInfo |
This helper gives you access to the type info given a type definition
|
| TypeKind |
And enumeration of the the kind of things that can be in a graphql type system
|
| TypeMismatchError |
|
| TypeMismatchError.GraphQLTypeToTypeKindMapping |
|
| TypeName |
|
| TypeName.Builder |
|
| TypeRedefinitionError |
|
| TypeResolutionEnvironment |
This is passed to a TypeResolver to help with object type resolution. |
| TypeResolutionParameters |
This class is a classic builder style one that SHOULD have been on have been on TypeResolutionEnvironment
but for legacy reasons was not. |
| TypeResolutionParameters.Builder |
|
| TypeResolver |
|
| TypeResolverProxy |
|
| TypeRuntimeWiring |
A type runtime wiring is a specification of the data fetchers and possible type resolver for a given type name.
|
| TypeRuntimeWiring.Builder |
|
| TypesImplementInterfaces |
Schema validation rule ensuring object and interface types have all the fields that they need to
implement the interfaces they say they implement.
|
| TypeUtil |
This class consists of static utility methods for operating on Type. |
| UnExecutableSchemaGenerator |
|
| UnicodeUtil |
Contains Unicode helpers for parsing StringValue types in the grammar
|
| UnionTypeDefinition |
|
| UnionTypeDefinition.Builder |
|
| UnionTypeError |
|
| UnionTypeExtensionDefinition |
|
| UnionTypeExtensionDefinition.Builder |
|
| UnionTypesChecker |
UnionType check, details in https://spec.graphql.org/June2018/#sec-Type-System.
|
| UnionWiringEnvironment |
|
| UniqueArgumentNames |
Unique argument names
A GraphQL field or directive is only valid if all supplied arguments are uniquely named.
|
| UniqueDirectiveNamesPerLocation |
https://facebook.github.io/graphql/June2018/#sec-Directives-Are-Unique-Per-Location
|
| UniqueFragmentNames |
|
| UniqueObjectFieldName |
|
| UniqueOperationNames |
A GraphQL document is only valid if all defined operations have unique names.
|
| UniqueVariableNames |
Unique variable names
|
| 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.
|
| UnresolvedTypeError |
|
| 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. |
| Util |
|
| ValidationContext |
|
| ValidationError |
|
| ValidationError.Builder |
|
| ValidationErrorClassification |
|
| ValidationErrorCollector |
|
| ValidationErrorCollector.MaxValidationErrorsReached |
Indicates that that maximum number of validation errors has been reached
|
| ValidationErrorType |
|
| ValidationUtil |
|
| Validator |
|
| Value<T extends Value> |
|
| ValuesResolver |
|
| ValuesResolver.ValueMode |
|
| ValuesResolverConversion |
This class, originally broken out from ValuesResolver contains code for the conversion of values
from one form (literal, external etc..) to another. |
| ValuesResolverLegacy |
|
| ValueToVariableValueCompiler |
|
| ValueTraverser |
This class allows you to traverse a set of input values according to the type system and optional
change the values present.
|
| ValueTraverser.InputElements |
|
| ValueUnboxer |
A value unboxer takes values that are wrapped in classes like Optional / OptionalInt etc..
|
| ValueVisitor |
|
| ValueVisitor.InputElements |
Represents the elements that leads to a value and type
|
| VariableAccumulator |
This accumulator class decides on whether to create a variable for a query argument and if so it tracks what variables were made.
|
| VariableDefaultValuesOfCorrectType |
|
| VariableDefinition |
|
| VariableDefinition.Builder |
|
| VariablePredicate |
This predicate indicates whether a variable should be made for this field argument OR whether it will be compiled
into a graphql AST literal.
|
| VariableReference |
|
| VariableReference.Builder |
|
| VariablesAreInputTypes |
|
| VariablesTypesMatcher |
|
| VariableTypesMatch |
|
| VariableValueWithDefinition |
|
| Vertex |
|
| Vertex.VertexData |
|
| VisibleFieldPredicate |
|
| VisibleFieldPredicateEnvironment |
|
| VisibleFieldPredicateEnvironment.VisibleFieldPredicateEnvironmentImpl |
|
| VisibleForTesting |
Marks fields, methods etc as more visible than actually needed for testing purposes.
|
| WiringEnvironment |
|
| WiringFactory |
A WiringFactory allows you to more dynamically wire in TypeResolvers and DataFetchers
based on the IDL definitions. |