All Classes and Interfaces
Class
Description
Base class for
GraphQlClient extensions that assist with building an
underlying transport, but otherwise delegate to the default
GraphQlClient implementation to execute requests.Base class for extensions of
GraphQlTester that mainly assist with
building the underlying transport, but otherwise delegate to the default
GraphQlTester implementation for actual request execution.Abstract, base class for transport specific
GraphQlClient.Builder
implementations.Base class for
GraphQlResponse that pre-implements the ability to
access a ResponseField.Implementation of
GraphQlSource.Builder that leaves it to subclasses
to initialize GraphQLSchema.Abstract, base class for transport specific
GraphQlTester.Builder
implementations.Convenient base class for a
SortStrategy.RuntimeWiringConfigurer that finds @SchemaMapping
annotated handler methods in @Controller classes declared in
Spring configuration, and registers them as DataFetchers.Annotation to bind a named GraphQL
argument
onto a method parameter.Resolver for a method parameter that is annotated with
@Argument.Resolver for a method parameter that is annotated with
@Arguments, similar to what
ArgumentMethodArgumentResolver does but using the full
full GraphQL arguments
map as the source for binding to the target Object rather than a specific
argument value within it.Simple container for the value from binding a GraphQL argument to a higher
level Object, along with a flag to indicate whether the input argument was
omitted altogether, as opposed to provided but set to the "null"
literal.
Resolver to obtain
Authentication.getPrincipal() from Spring Security
context via SecurityContext.getAuthentication() for parameters
annotated with AuthenticationPrincipal.An extension of
HandlerMethod for annotated handler methods adapted to
BatchLoaderWithContext or
MappedBatchLoaderWithContext with the list of keys and
BatchLoaderEnvironment as their input.Registry for functions to batch load data values, given a set of keys.
Spec to complete the registration of a batch loading function.
Annotation for a handler method that batch loads field values, given a list
of source/parent values.
Base class for
DocumentSource implementations providing support for
caching loaded documents.TypeResolver that tries to find a GraphQL Object type based on the
class name of a value returned from a DataFetcher.GraphQlRequest for client side use.GraphQlResponse for client use, with further options to handle the
response.Extends
ResponseField to add options for decoding the field value.Contract to adapt a container object for a window of elements from a larger
result set to
Connection.Convenient base class for implementations of
ConnectionAdapter.GraphQLTypeVisitor that looks for Connection
fields in the schema, and decorates their registered DataFetcher in
order to adapt return values to Connection.TypeDefinitionConfigurer that generates "Connection" types by looking
for fields whose type definition name ends in "Connection", considered by the
GraphQL Cursor Connections Specification
to be a Connection Type, and adding the required type definitions
if they don't already exist.Annotation to bind a method parameter to an attribute from the
main GraphQLContext.Resolver for a
@ContextValue annotated method parameter.No-op resolver for method arguments of type
Continuation.Strategy to encode and decode a String cursor to make it opaque for clients.
Strategy to convert an Object that represents the position of an item within
a paginated result set to and from a String cursor.
Contract to resolve exceptions from
DataFetchers.Adapter for
DataFetcherExceptionResolver that pre-implements the
asynchronous contract and exposes the following synchronous protected methods:
DataFetcherExceptionResolverAdapter.resolveToSingleError(java.lang.Throwable, graphql.schema.DataFetchingEnvironment)
DataFetcherExceptionResolverAdapter.resolveToMultipleErrors(java.lang.Throwable, graphql.schema.DataFetchingEnvironment)
An extension of
HandlerMethod for annotated handler methods adapted
to DataFetcher with DataFetchingEnvironment
as their input.Context that holds information for metadata collection during observations
for
data fetching operations.Interface for an
ObservationConvention
for data fetching observations.Resolver for
DataFetchingEnvironment and related values that can be
accessed through the DataFetchingEnvironment such as:
GraphQLContext
DataFetchingFieldSelectionSet
Locale or Optional<Locale>
as well as arguments of typeResolver for a
DataLoader obtained via
DataFetchingEnvironment.getDataLoader(String).Contract for access to the
DataLoaderRegistry for each request for
the purpose of registering DataLoader instances.Default implementation of
BatchLoaderRegistry that stores batch loader
registrations.Default implementation for a
DataFetcherObservationConvention
extracting information from a DataFetcherObservationContext.GraphQlRequest for server side handling, adding the transport (e.g.GraphQlResponse for server use that wraps the ExecutionResult
returned from GraphQL and also exposes the actual
ExecutionInput instance passed into it.DefaultExecutionGraphQlResponse.Builder<B extends DefaultExecutionGraphQlResponse.Builder<B,R>,R extends ExecutionGraphQlResponse>
Builder to transform the response's
ExecutionResult.ExecutionGraphQlService that uses a GraphQlSource to obtain a
GraphQL instance and perform query execution.Default implementation for a
ExecutionRequestObservationConvention
extracting information from a ExecutionRequestObservationContext.Default implementation of
GraphQlRequest.Default implementation of
RSocketGraphQlTester.Builder that wraps
an RSocketGraphQlClient.Builder.Strategy to locate a GraphQL document by a name.
Decorator for a
CursorStrategy that applies a CursorEncoder
to the cursor String to make it opaque for external use.Common categories to use to classify for exceptions raised by
DataFetcher's that can enable a client to make automated
decisions.Implementation of
GraphQlRequest for request handling through GraphQL
Java with support for customizing the ExecutionInput passed into
GraphQL.Implementation of
GraphQlResponse that wraps the ExecutionResult
returned from GraphQL to expose it as GraphQlResponse,
also providing access to the ExecutionInput used for the request.Strategy to execute a GraphQL request by invoking GraphQL Java.
GraphQlTester that executes requests through an
ExecutionGraphQlService on the server side, without a client.Default
ExecutionGraphQlServiceTester.Builder implementation.Context that holds information for metadata collection during observations
for
GraphQL requests.Interface for an
ObservationConvention for GraphQL requests.Spring WebFlux handler to serve a GraphiQl UI page.
Spring MVC handler to serve a GraphiQl UI page.
Binder that instantiates and populates a target Object to reflect the
complete structure of the
GraphQL arguments input map.Define a workflow to execute GraphQL requests that is independent of the
underlying transport.
Defines a builder for creating
GraphQlClient instances.Declare options to gather input for a GraphQL request and execute it.
Declares options to decode a field for a single response operation.
Declares options to decode a field in each response of a subscription.
Base class for exceptions from
GraphQlClient.Interceptor for
GraphQlClient requests.Contract for delegation of single response requests to the rest of the chain.
Contract for delegation of subscription requests to the rest of the chain.
ContextAccessor that enables support for reading and writing values
to and from a GraphQLContext.Declares a method as a handler of exceptions raised while fetching data
for a field.
WebFlux.fn Handler for GraphQL over HTTP requests.
GraphQL handler to expose as a WebMvc functional endpoint via
RouterFunctions.Documented
KeyValues for GraphQL server observations.Instrumentation that creates
observations for GraphQL requests and data fetcher operations.Specialization of the
Repository stereotype that marks a repository
as intended for use in a GraphQL application for data fetching.Represents a GraphQL request with the inputs to pass to a GraphQL service
including a
document, operationName, and variables.Represents a GraphQL response with the result of executing a request operation.
Handler for GraphQL over RSocket requests.
Strategy to resolve a
GraphQL and a GraphQLSchema.Common configuration options for all
GraphQlSource builders,
independent of how GraphQLSchema is created.GraphQlSource builder that relies on parsing schema definition
files and uses a RuntimeWiring to create the underlying
GraphQLSchema.Define a workflow to test GraphQL requests that is independent of the
underlying transport.
A builder to create a
GraphQlTester instance.Contains a decoded entity and provides options to assert it
Contains a List of decoded entities and provides options to assert them.
Declare options to filter out expected errors or inspect all errors and verify
there are no unexpected errors.
Options available to assert the response values at the current path.
Declare options to gather input for a GraphQL request and execute it.
Declare options to check the data and errors of a GraphQL response.
Declare options available to assert a GraphQL Subscription response.
Declare options to switch to different part of the GraphQL response.
Contract for executing GraphQL requests over some transport.
Exception raised by a
GraphQlTransport or used to wrap an exception
from a GraphQlTransport implementation.WebSocketHandler for GraphQL based on
GraphQL Over
WebSocket Protocol and for use in a Spring WebFlux application.
WebSocketHandler for GraphQL based on
GraphQL Over
WebSocket Protocol and for use on a Servlet container with
spring-websocket.Represents a GraphQL over WebSocket protocol message.
Enum for a message type as defined in the GraphQL over WebSocket spec proposal.
Strategy interface for resolving method parameters into argument values in
the context of a given
DataFetchingEnvironment.Container for a list of resolvers that looks for one that supports a given
method parameter type, and delegates to it.
GraphQL over HTTP client that uses
WebClient.Builder for the GraphQL over HTTP client.
GraphQL over HTTP tester that uses
WebTestClient and supports tests
with or without a running server, depending on how WebTestClient is
configured.Builder for the GraphQL over HTTP tester.
Extension of
HandlerMethod that adds support for invoking the
underlying handler methods.Strategy to convert a
keyset to and
from a JSON String for use with ScrollPositionCursorStrategy.Annotation to bind a method parameter to an attribute from the
local GraphQLContext.Resolver for a
@LocalContextValue annotated method
parameter.Indicates that no GraphQL schema definition was configured on the
GraphQlSource.Builder.@MutationMapping is a composed annotation that acts as a
shortcut for @SchemaMapping with
typeName="Mutation".Resolver to obtain
Principal from Spring Security context via
SecurityContext.getAuthentication().Resolver for a method parameter that is an interface annotated with
@ProjectedPayload.Main class to create a
DataFetcher from a Query By Example repository.Builder for a Query by Example-based
DataFetcher.Callback interface that can be used to customize QueryByExampleDataFetcher
QueryByExampleDataFetcher.Builder to change its configuration.Builder for a reactive Query by Example-based
DataFetcher.Callback interface that can be used to customize QueryByExampleDataFetcher
QueryByExampleDataFetcher.ReactiveBuilder to change its configuration.Main class to create a
DataFetcher from a Querydsl repository.Builder for a Querydsl-based
DataFetcher.Callback interface that can be used to customize QuerydslDataFetcher
QuerydslDataFetcher.Builder to change its configuration.Builder for a reactive Querydsl-based
DataFetcher.Callback interface that can be used to customize QuerydslDataFetcher
QuerydslDataFetcher.ReactiveBuilder to change its configuration.@QueryMapping is a composed annotation that acts as a
shortcut for @SchemaMapping with
typeName="Query".Reactive
DataFetcherExceptionResolver
for Spring Security exceptions.DocumentSource that looks for a document Resource under a set
of locations and trying a number of different file extension.Represents a GraphQL response error.
Representation for a field in a GraphQL response, with options to examine
the field value and errors.
GraphQL over RSocket client that uses
RSocketRequester.Builder for the GraphQL over HTTP client.
Interceptor for server handling of GraphQL over RSocket requests,
allowing customization of the
ExecutionInput and
the ExecutionResult.Contract for delegation to the rest of the chain.
GraphQlRequest implementation for server
handling over RSocket.GraphQlResponse implementation for server
handling over RSocket.Builder to transform a
RSocketGraphQlResponse.GraphQL over RSocket tester that uses
RSocketRequester.Builder for a GraphQL over RSocket tester.
Callbacks that allow applying changes to the
RuntimeWiring.Builder
in GraphQlSource.Builder.Spring WebFlux functional handler that renders the
GraphQLSchema printed via SchemaPrinter.Spring MVC functional handler that renders the
GraphQLSchema printed via SchemaPrinter.Annotation to express the mapping of a handler method to a GraphQL type and
field pair.
Declares an
SchemaMappingInspector.inspect(GraphQLSchema, RuntimeWiring) method that checks
if schema mappings.Report produced as a result of inspecting schema mappings.
Information about a schema type skipped during the inspection.
Strategy to convert a
ScrollPosition to and from a String cursor.Container for parameters that limit result elements to a subrange including a
relative
ScrollPosition, number of elements, and direction.ThreadLocalAccessor to extract and restore security context through
SecurityContextHolder.DataFetcherExceptionResolver
for Spring Security exceptions.Specialized
DataFetcher that exposes additional details such as
return type information.GraphQlRequest for deserialization from a request.Adapter for
Slice to Connection.Resolver for method arguments of type
Sort.Strategy to extract
Sort details from GraphQL arguments.Resolver for the source/parent of a field, obtained via
DataFetchingEnvironment.getSource().Container for parameters that limit result elements to a subrange including a
relative position, number of elements, and direction.
Resolver for a method argument of type
Subrange initialized
from "first", "last", "before", and "after" GraphQL arguments.WebSocket
GraphQlTransportException raised when a subscription
ends with an "error" message.Contract for a component that is invoked when a GraphQL subscription
Publisher ends with an error.Adapter for
SubscriptionExceptionResolver that pre-implements the
asynchronous contract and exposes the following synchronous protected methods:
SubscriptionExceptionResolverAdapter.resolveToSingleError(java.lang.Throwable)
SubscriptionExceptionResolverAdapter.resolveToMultipleErrors(java.lang.Throwable)
@SubscriptionMapping is a composed annotation that acts as a
shortcut for @SchemaMapping with
typeName="Subscription".An exception raised after a GraphQL subscription
Publisher ends with an exception, and after that
exception has been resolved to GraphQL errors.Callback that allows customizing the
TypeDefinitionRegistry created
from parsed schema files.Helper for
GraphQLTypeVisitors registered via
GraphQlSource.Builder.typeVisitors(List) that is exposed as a
variable in TraverserContext.Base contract for the HTTP and WebSocket
GraphQlClient extensions.Base builder for GraphQL clients over a Web transport.
Contract for common handling of a GraphQL request over HTTP or WebSocket,
for use with Spring MVC or Spring WebFlux.
Builder for a
WebGraphQlHandler that executes a
WebGraphQlInterceptor chain followed by a
ExecutionGraphQlService.Interceptor for server handling of GraphQL over HTTP or WebSocket requests,
providing access to info about the underlying HTTP request or WebSocket
handshake, and allowing customization of the
ExecutionInput and
the ExecutionResult.Contract for delegation to the rest of the chain.
GraphQlRequest implementation for server
handling over HTTP or WebSocket.GraphQlResponse implementation for server
handling over HTTP or over WebSocket.Builder to transform a
WebGraphQlResponse.Server-side tester, without a client, that executes requests through a
WebGraphQlHandler.Common builder for Web
GraphQlTester extensions.WebSocket related
GraphQlTransportException raised when the connection
is closed while a request or subscription is in progress.GraphQL over WebSocket client that uses
WebSocketClient.Builder for a GraphQL over WebSocket client.
An extension of
GraphQlClientInterceptor with additional methods to
for WebSocket interception points.An extension of
WebGraphQlInterceptor with additional methods
to handle the start and end of a WebSocket connection.WebGraphQlRequest extension for
server handling of GraphQL over WebSocket requests.GraphQL over WebSocket client that uses
WebSocketClient.Builder for a GraphQL over WebSocket tester.
Expose information about the underlying WebSocketSession including the
session id, the attributes, and HTTP handshake request.
Adapter for
Window to Connection.