All Classes and Interfaces
Class
Description
Base class for interceptors that extract an
Authentication from
the payload of a "connection_init" GraphQL over WebSocket message.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.Abstract, base class for transport specific
GraphQlClient.SyncBuilder
implementations.Abstract base class for GraphQL over HTTP handlers.
Abstract base class for GraphQL over HTTP handlers.
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
and @BatchMapping methods in @Controller
classes, and registers them as DataFetchers.Convenient base for classes that find annotated controller method with argument
values resolved from a
DataFetchingEnvironment.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.
Strategy to extract an
Authentication from the payload of a
"connection_init" GraphQL over WebSocket message.Resolver to obtain
Authentication.getPrincipal() from Spring Security
context via SecurityContext.getAuthentication() for parameters
annotated with AuthenticationPrincipal.Extension of
AbstractAuthenticationWebSocketInterceptor for use with
the WebFlux GraphQL transport.Extension of
AbstractAuthenticationWebSocketInterceptor for use with
the WebMVC GraphQL transport.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.
AuthenticationExtractor that extracts a
bearer token.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.Helper to use a single
ContextSnapshotFactory instance by saving and
obtaining it to and from Reactor and GraphQL contexts.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)
Invocable handler to use as a
DataFetcher.Extension of
InvocableHandlerMethodSupport for handler methods that
resolve argument values from a DataFetchingEnvironment.Mapping information for a controller method to be registered as a
DataFetcher.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.Resolver 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.Simple wrapper around a
GraphQlClient that prepares the request
from classes generated with the
DGS Code Generation library.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.Annotation for mapping a handler method to a federated schema type.
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.Detects
@EntityMapping handler methods on controllers
declared in Spring configuration, and provides factory methods to create
GraphQLSchema or SchemaTransformer.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.
Base builder for creating and initializing a
GraphQlClient.Builder to create a
GraphQlClient with a non-blocking execution
chain and transport.Declare options to gather input for a GraphQL request and execute it.
Declares options to decode a field in a single response.
Declares options to decode a field in each response of a subscription.
Declares options to decode a field in a single response.
Builder to create a
GraphQlClient instance with a
synchronous execution chain and transport.Base class for exceptions from
GraphQlClient.Interceptor for
GraphQlClient requests for use in a non-blocking
execution chain with a non-blocking GraphQlTransport..Contract to delegate to the rest of a non-blocking execution 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.RequestPredicate implementations tailored for GraphQL reactive endpoints.RequestPredicate implementations tailored for GraphQL endpoints.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.GraphQL handler that supports the
GraphQL
Server-Sent Events Protocol and to be exposed as a WebFlux.fn endpoint via
RouterFunctions.GraphQL handler that supports the
GraphQL
Server-Sent Events Protocol and to be exposed as a WebMvc functional endpoint via
RouterFunctions.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.
Extension of
DataFetcherExceptionResolver with overloaded method to
apply at the point of DataFetcher invocation to allow local exception handling.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.
GraphQL over HTTP client with that uses
RestClient in a blocking
execution chain.Builder for the GraphQL over HTTP client with a blocking execution chain.
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.Raised when a representation could not be resolved because:
The "__typename" argument is missing.
Specialization of
RepresentationException that indicates a resolver
returned null or completed empty.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.
Inspect schema mappings on startup to ensure the following:
Schema fields have either a
DataFetcher registration or a
corresponding Class property.Strategy to resolve the Java class(es) for a
GraphQLObjectType, effectively
the reverse of TypeResolver, for schema inspection purposes.Helps to configure
SchemaMappingInspector.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.Subrange implementation for a ScrollPosition cursor.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.Interceptor of
GraphQlClient requests for use in a blocking execution
chain with a SyncGraphQlTransport.Contract to delegate to the rest of a blocking execution chain.
Contract for blocking execution of GraphQL requests over some transport.
Callback that allows customizing the
TypeDefinitionRegistry created
from parsed schema files.Helps
GraphQLTypeVisitors to recognize whether a type
is the subscription type.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, as well as client-side
cancellation of subscriptions.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.