Netflix/dgs-framework

This system is the Netflix DGS Framework, a Kotlin and Java library for building GraphQL APIs on top of Spring Boot. It provides a comprehensive set of features including data fetching, subscription handling, and automated Relay-style pagination, while integrating with Spring GraphQL for execution and context management. The framework supports modern development needs through reactive WebFlux execution, Jackson 3 serialization with backward compatibility for Jackson 2, and detailed metrics instrumentation via Micrometer.

50 changes.

The project underwent a major architectural overhaul to modernize the DGS framework, introducing reactive query execution, JPMS support, and a new platform BOM for dependency management. Significant efforts were made to align with standard GraphQL Java contexts, upgrade to Jackson 3, and refactor core execution and error handling infrastructure. This period also saw the addition of new capabilities such as Relay-style pagination, Bean Validation integration, and comprehensive test coverage for these new features.

27 changes.

This period focused on deeply integrating DGS with Spring GraphQL, rewriting core query executors and interceptors to leverage Spring's execution model and auto-configuration. It introduced comprehensive support for Spring WebFlux, reactive data fetchers, and WebSocket subscriptions, while adding features like Automated Persisted Queries and enhanced startup diagnostics. The work also included extensive example applications and test coverage to validate the new integration patterns and configuration properties.

12 changes.

This period focused on enabling Java Platform Module System (JPMS) support across all core DGS modules by adding module descriptors and resolving internal dependency exports. Concurrently, the framework introduced a Jackson-agnostic JSON mapping abstraction to support both Jackson 2 and Jackson 3, providing backward compatibility and new example projects to demonstrate serialization options.

This change introduces support for Automated Persisted Queries (APQ) in the DGS Spring GraphQL module. It adds a new auto-configuration (\DgsAPQSupportAutoConfiguration\) that enables APQ via the \dgs.graphql.apq.enabled\ property. When enabled, it configures a \PreparsedDocumentProvider\ wrapper to handle persisted query lookups and integrates with a Caffeine-backed cache (\AutomatedPersistedQueryCaffeineCache\) for storing query documents. The cache can be optionally monitored via Micrometer metrics if a \MeterRegistry\ is present. Configuration properties allow tuning the cache size and expiration via \dgs.graphql.apq.default-cache.caffeine-spec\.

graphql-dgs-spring-graphql/src/main/kotlin/com/netflix/graphql/dgs/apq · high confidence

The subscription types module now includes the data models required for the GraphQL over WebSocket Protocol. This adds a CloseCode enum defining standard WebSocket close codes (such as BadRequest, Unauthorized, and InternalServerError) and a Message sealed class hierarchy representing protocol messages like ConnectionInit, ConnectionAck, Ping, Pong, Subscribe, Next, Error, and Complete, enabling structured serialization and deserialization of WebSocket traffic.

graphql-dgs-subscription-types/src/main/kotlin/com/netflix/graphql/types/subscription/websockets · high confidence

The graphql-dgs-client library now includes a module-info.java file, enabling Java Platform Module System (JPMS) support. This allows the client to be used as a named module in modular Java applications, explicitly declaring its dependencies on Kotlin stdlib, Jackson, Spring Web, Reactor, and internal DGS subscription types, while exporting its core client and exception packages.

graphql-dgs-client/src/main/java · high confidence

This change introduces the \graphql-dgs-jackson2\ module, allowing users to opt back into Jackson 2 for JSON serialization instead of the default Jackson 3. By including this module, the application automatically configures a \DgsJsonMapper\ using Jackson 2 libraries (locked at version 2.20.1, including Kotlin and JavaTime modules) and registers it with Spring Boot auto-configuration. This configuration takes precedence over the default Jackson 3 mapper unless the user explicitly sets \dgs.graphql.preferred-json-mapper=jackson3\. The module also updates dependency locks to reflect the required Jackson 2 artifacts and integrates with existing test auto-configurations.

graphql-dgs-jackson2 · high confidence

This change introduces a new reactive Spring GraphQL example application located in the \reactive\ package. It provides a \ReactiveSpringGraphQLExampleApp\ entry point that configures a Caffeine-based cache for preparsed GraphQL documents to improve performance, and a \MyContextBuilder\ component that implements \DgsReactiveCustomContextBuilderWithRequest\ to construct a custom reactive context from HTTP headers and server requests.

graphql-dgs-spring-graphql-example-java-webflux/src/main/java/com/netflix/graphql/dgs/example/reactive · high confidence

The example application now includes a complete GraphQL schema definition (\schema.graphqls\) featuring queries for data loaders with both DgsContext and GraphQLContext, pagination via the \@connection\ directive, custom scalars (LocalTime), file uploads, and cookie handling. Additionally, static frontend assets (HTML, JavaScript bundles, service worker, and manifest) have been added to serve the client-side application.

graphql-dgs-example-shared/src/main/resources · high confidence

The spring-graphql module now includes a module-info.java file, enabling Java Platform Module System (JPMS) support and explicitly exporting auto-configuration packages to Spring and Kotlin reflection modules. Additionally, a new @ConditionalOnDgsReload annotation has been introduced to allow components to be conditionally loaded only when runtime reloading is enabled, a feature intended for local and development environments to manage performance impacts during component reloading.

graphql-dgs-spring-graphql/src/main/java · high confidence

The library now provides explicit Spring Boot configuration metadata via a new \spring-configuration-metadata.json\ file, enabling IDE support and auto-completion for DGS-specific properties such as \dgs.graphql.path\, \dgs.graphql.graphiql.enabled\, and \dgs.graphql.strict-mode.enabled\. Additionally, \spring.factories\ has been updated to register environment post-processors and failure analyzers, improving the developer experience during configuration and startup diagnostics.

graphql-dgs-spring-graphql/src/main/resources/META-INF · high confidence

Two new example applications have been added to demonstrate the framework's support for both Jackson 2 and Jackson 3 serialization libraries. The \graphql-dgs-example-jackson2-only\ project configures the application to use Jackson 2 (specifically \com.fasterxml.jackson.databind.ObjectMapper\) and includes tests verifying that Jackson 3 is absent from the classpath while GraphQL queries and various client types (MockMvc, RestClient, WebClient, Custom) function correctly. Conversely, the \graphql-dgs-example-jackson3-only\ project is configured to use Jackson 3 (specifically \tools.jackson.databind.json.JsonMapper\) and includes tests ensuring Jackson 2 is excluded while validating the same set of GraphQL operations and client integrations.

graphql-dgs-example-jackson2-only, graphql-dgs-example-jackson3-only · high confidence

The new graphql-dgs-pagination module automatically generates Relay-style pagination types (Connection, Edge, and PageInfo) for GraphQL schema types marked with the @connection directive. This feature extends support to Object types, Interfaces, and Unions, allowing developers to enable cursor-based pagination simply by annotating their schema definitions. The module includes Spring Boot auto-configuration and an environment post-processor to manage this behavior, ensuring that the necessary schema definitions are merged into the executable schema without manual boilerplate.

graphql-dgs-pagination/src · high confidence

The DGS framework now automatically registers extended scalar types (such as DateTime, Currency, and various numeric types) via a new auto-configuration class. This registration is controlled by specific configuration properties under the \dgs.graphql.extensions.scalars\ prefix, allowing users to enable or disable entire categories of scalars (e.g., time-dates, objects, numbers) as well as specific types like BigDecimal and BigInteger within the numbers group.

graphql-dgs-extended-scalars/src/main/kotlin · high confidence

The DGS Framework now includes an auto-configuration module that integrates graphql-java's Bean Validation extensions. When the property dgs.graphql.extensions.validation.enabled is true (the default), the system automatically registers validation rules into the GraphQL runtime wiring. Developers can further customize these validation rules by providing beans that implement the new ValidationRulesBuilderCustomizer interface.

graphql-dgs-extended-validation/src/main · high confidence

The subscription-related type definitions, including \OperationMessage\ and its payload variants (\EmptyPayload\, \DataPayload\, \SSEDataPayload\, \QueryPayload\), along with protocol constants for WebSocket subprotocols (\graphql-ws\ and \graphql-transport-ws\), have been extracted into the new \graphql-dgs-subscription-types\ module. This change centralizes the data structures used for GraphQL over WebSocket and SSE subscriptions, making them available as a shared dependency for clients and servers implementing these protocols.

graphql-dgs-subscription-types/src/main/kotlin/com/netflix/graphql/types/subscription · high confidence

This change introduces a new example application (\SpringGraphQLExampleApp\) that demonstrates integration with Spring GraphQL. It includes a custom context builder (\MyContextBuilder\) to populate the DGS context and configures a Caffeine-based cache for pre-parsed GraphQL documents to optimize query processing performance.

graphql-dgs-spring-graphql-example-java/src/main/java/com/netflix/graphql/dgs/example · high confidence

The application now includes a new configuration file enabling GraphiQL, configuring the WebSocket endpoint at /graphql, and exposing metrics. Additionally, a GraphQL schema is defined that exposes query fields for Mono and Flux types, supporting the reactive programming model used in this WebFlux-based example.

graphql-dgs-spring-graphql-example-java-webflux/src/main/resources · high confidence

This change adds the \DgsReactiveQueryExecutor\ interface, enabling reactive GraphQL query execution via \Mono\ results for use in tests and internal framework logic, alongside a new \module-info.java\ file that configures the module for Java Platform Module System (JPMS) compatibility with dependencies like Spring WebFlux and JsonPath.

graphql-dgs-reactive/src/main/java · high confidence

A new \@Unstable\ annotation has been added to the \com.netflix.graphql.dgs.support\ package. This marker allows developers to flag specific components (such as methods, fields, or types) as having an unstable API or implementation that is likely to change. Its presence serves as a warning to users that the marked component is not yet mature and should be used at their own risk.

graphql-dgs/src/main/java/com/netflix/graphql/dgs/support · high confidence

The core GraphQL DGS module now includes a module-info.java file, enabling Java Platform Module System (JPMS) support. This change explicitly declares module dependencies on Spring, Kotlin, and GraphQL libraries, and exports specific internal packages to allow the Spring GraphQL, reactive, and Micrometer modules to access necessary internal APIs for auto-configuration.

graphql-dgs/src/main/java · high confidence

The framework introduces several new capabilities for managing data loaders and schema registration. Developers can now instrument data loader dispatch and completion via the new \DgsDataLoaderInstrumentation\ and \DgsDataLoaderInstrumentationContext\ interfaces, and customize loader registration or wrap batch loaders using \DgsDataLoaderCustomizer\. Configuration of data loader options is now possible through \DgsDataLoaderOptionsProvider\. For development workflows, a new \DgsDataLoaderReloadController\ interface allows programmatic reloading of data loaders. Additionally, \DgsCodeRegistryBuilder\ provides a consistent mechanism for registering data fetchers programmatically, and \DgsExecutionResult\ now supports setting HTTP headers and status codes directly.

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs · high confidence

The shared example module now includes new classes demonstrating how to extend the GraphQL schema and customize the request context. \ExtraTypeDefinitionRegistry\ adds a \myField\ to the \Query\ type, while \ExtraCodeRegistry\ provides a corresponding data fetcher. Additionally, \ExampleGraphQLContextContributor\ shows how to inject custom values into the \GraphQLContext\ based on request headers, and \MyContext\ provides a sample context object.

graphql-dgs-example-shared/src/main/java/com/netflix/graphql/dgs/example/shared/context · high confidence

The example application now includes a comprehensive set of new data fetchers in the shared module, demonstrating various GraphQL capabilities. These include basic queries and mutations (HelloDataFetcher, RatingMutation), concurrent execution with instrumentation (ConcurrentDataFetcher), data loader batching and context propagation (HelloDataFetcher), subscription streams for stock updates (SubscriptionDataFetcher), and specific type handling for movies (ActionMovieDataFetcher, ScaryMovieDataFetcher, MovieDataFetcher). Additionally, request header access is now supported via RequestHeadersDataFetcher.

graphql-dgs-example-shared/src/main/java/com/netflix/graphql/dgs/example/shared/datafetcher · high confidence

The example shared module now includes several new data loader implementations that showcase advanced DataLoader features. These include loaders that access custom context via DgsContext (ExampleLoaderWithContext) and standard GraphQLContext (ExampleLoaderWithGraphQLContext), a loader demonstrating error handling with the Try type (MessagesDataLoaderWithException), and loaders illustrating scheduled dispatch behavior using DgsDispatchPredicate (MessageDataLoaderWithDispatchPredicate). These additions provide concrete examples for users on how to integrate context, handle errors, and control batching timing in their own applications.

graphql-dgs-example-shared/src/main/java/com/netflix/graphql/dgs/example/shared/dataLoader · high confidence

Added a new example application (\graphql-dgs-example-jackson-both\) that runs on the classpath with both Jackson 2 and Jackson 3 libraries. The example verifies that Jackson 2 is preferred for autoconfiguration while both versions remain available, and demonstrates that both Jackson 2 and Jackson 3 client classes function correctly against the GraphQL endpoint.

graphql-dgs-example-jackson-both · high confidence

Added ExampleInstrumentationDependingOnContextContributor, a Spring component that extends SimplePerformantInstrumentation to verify that context contributors have run before execution. It checks for the CONTRIBUTOR\_ENABLED\_CONTEXT\_KEY in the GraphQLContext during state creation and, if present, injects that indicator into the execution result's extensions, making the context contributor's effect observable to clients for testing purposes.

graphql-dgs-example-shared/src/main/java/com/netflix/graphql/dgs/example/shared/instrumentation · high confidence

The DgsReactiveCustomContextBuilderWithRequest interface is introduced, allowing custom context builders to access the underlying Spring WebFlux ServerRequest, HTTP headers, and extensions when building the reactive context. This enables more granular control over context construction in reactive GraphQL execution by providing direct access to the incoming request metadata.

graphql-dgs-reactive/src/main/kotlin/com/netflix/graphql/dgs/reactive · high confidence

A new Python-based automation tool has been added to the scripts directory to streamline the validation of DGS example projects. The \test-examples.py\ script clones the Java and Kotlin example repositories (defined in \config.yml\), infers the current framework and Spring Boot versions from the local build files, updates the example projects to use these versions, and executes Gradle builds to verify compatibility. This includes helper utilities in \common.py\ for colored console output and configuration management, enabling developers to quickly test example applications against the latest framework changes.

scripts · high confidence

Added new Java classes (ActionMovie, Message, Movie, Rating, ScaryMovie, Stock) to the shared types package, providing the data structures used by the GraphQL example application.

graphql-dgs-example-shared/src/main/java/com/netflix/graphql/dgs/example/shared/types · high confidence

The repository has been initialized with standard open-source governance and development files. This includes the Apache 2.0 License and NOTICE files, a Code of Conduct, a Security policy, and a Contributor guide. Development tooling is configured via an EditorConfig for consistent code style, a .gitignore for build artifacts and IDE files, and an SDKMAN configuration to enforce Java 17. A Makefile is provided to simplify common tasks such as formatting, testing, and publishing snapshots.

(repo-wide) · high confidence

The reactive WebFlux example now includes data fetchers demonstrating integration with Spring GraphQL, such as the new SpringGraphQLDataFetchers controller for query mappings, alongside existing DGS reactive components like ReactiveDataFetchers and UsingWebFluxReactorContext. It also introduces a new FileUploadMutation data fetcher to handle multipart file uploads via the Upload scalar, and adds a WithCookie component to demonstrate reading and setting HTTP cookies in a reactive context.

graphql-dgs-spring-graphql-example-java-webflux/src/main/java/com/netflix/graphql/dgs/example/reactive/datafetchers · high confidence

The DGS Extended Scalars module now includes Spring Boot auto-configuration support. A new metadata file defines configuration properties (such as \dgs.graphql.extensions.scalars.enabled\ and specific scalar group toggles) that allow users to control which scalar extensions are registered. Additionally, an auto-configuration import file registers \DgsExtendedScalarsAutoConfiguration\, enabling automatic setup of these scalars when the library is on the classpath.

graphql-dgs-extended-scalars/src/main/resources · high confidence

The library now registers its Spring Boot auto-configuration classes via the standard Spring Boot 2.7+ mechanism. Specifically, the file \META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports\ has been added to declare \DgsSpringGraphQLAutoConfiguration\ and \DgsAPQSupportAutoConfiguration\, enabling automatic setup of the Spring GraphQL integration and Automatic Persisted Queries (APQ) support without manual configuration.

graphql-dgs-spring-graphql/src/main/resources/META-INF/spring · high confidence

The example application now includes a set of new data fetcher implementations demonstrating Spring GraphQL capabilities alongside the existing DGS framework. This includes a \ControllerExceptionHandler\ for centralized error handling, \FileUploadMutation\ for handling multipart file uploads, and \GreetingBatchLoader\ for implementing DataLoader batching. Additionally, new components such as \MyInstrumentation\ for custom response headers, \WithCookie\ and \WithHeader\ for accessing HTTP cookies and headers, and \SpringGraphQLDataFetchers\ for standard query mappings have been added to illustrate these integration patterns.

graphql-dgs-spring-graphql-example-java/src/main/java/com/netflix/graphql/dgs/example/datafetcher · high confidence

The DGS reactive framework now allows data fetcher methods to leverage existing Spring WebFlux argument resolvers. A new adapter class bridges the gap between DGS's internal method invocation model and Spring's \SyncHandlerMethodArgumentResolver\, enabling developers to use standard Spring WebFlux annotations and argument types (such as \ServerRequest\ or reactive types) directly within their GraphQL data fetchers without manual extraction logic.

graphql-dgs-reactive/src/main/kotlin/com/netflix/graphql/dgs/reactive/internal/method · high confidence

The graphql-dgs-mocking module has been removed from the codebase. This change eliminates the ability to automatically generate mock data for GraphQL schemas, including scalar types (String, Boolean, Int, Float, ID), lists, and objects, as well as the support for providing custom mock data via the MockProvider interface. Users relying on this library for local development or testing of GraphQL APIs will need to migrate to an alternative mocking solution.

graphql-dgs-mocking · high confidence

The internal logging infrastructure for GraphQL queries has been removed, specifically deleting the \LogEvent\ data class, the \LogService\ interface, and the \LogSanitizer\ and \QuerySanitizer\ classes. This eliminates the capability to log detailed GraphQL query structures, variables, and responses, as well as the associated logic for sanitizing sensitive data within those logs.

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/logging · high confidence

The graphql-dgs-subscription-types module now includes a module-info.java file, enabling Java Platform Module System (JPMS) compatibility. This change explicitly declares dependencies on the Kotlin standard library, Jackson annotations, JetBrains annotations, and the GraphQL Java library, while exporting the subscription and websocket packages to other modules.

graphql-dgs-subscription-types/src/main/java · high confidence

The example application now includes a GraphQL schema defining three new query fields: \greetings\, \greetingFromBatchLoader\, and \withControllerAdvice\, along with a \Person\ input type. This schema supports the new Spring GraphQL style data loader example and the exception handling setup via \@ControllerAdvice\.

graphql-dgs-spring-graphql-example-java/src/main/resources/schema · high confidence

The library now includes a \spring-configuration-metadata.json\ file that exposes DGS GraphQL Micrometer properties (such as enabling metrics, autotime, outcome tag customizers, and query signature caching) for IDE support and externalized configuration. Additionally, an \AutoConfiguration.imports\ file has been added to register \DgsGraphQLMicrometerAutoConfiguration\, ensuring the auto-configuration is picked up by Spring Boot 3's new import-based mechanism.

graphql-dgs-spring-boot-micrometer/src/main/resources · high confidence

The DGS annotation framework has been updated to improve usability and consistency. New shorthand annotations (@DgsQuery, @DgsMutation, @DgsSubscription) are now available to simplify data fetcher definitions, while the core @DgsData annotation now supports multiple instances per method and includes a 'trivial' flag for performance optimization. Additionally, @DgsComponent can now be applied to methods, and most framework annotations now inherit metadata via @Inherited. The @InputArgument annotation has been refactored to use @AliasFor for 'name' and 'value' parameters, and the 'collectionType' parameter is now deprecated as it is inferred automatically.

graphql-dgs/src/main/java/com/netflix/graphql/dgs · high confidence

The autoconfiguration module now uses a unified \DgsConfigurationProperties\ class to manage settings such as schema locations, strict mode, federation, and introspection behavior, replacing scattered property definitions. Additionally, a new \SourceArgumentResolver\ bean is registered, enabling developers to easily access the GraphQL \Source\ object within \@DgsData\ fetchers.

graphql-dgs-spring-graphql/src/main/kotlin/com/netflix/graphql/dgs/autoconfig · high confidence

The DGS framework now stores the request context in the standard GraphQLContext rather than a custom internal structure, enabling better interoperability with GraphQL Java features like Dataloaders. A new DgsCustomContextBuilderWithRequest interface allows custom context builders to access HTTP headers and the web request, taking precedence over the legacy DgsCustomContextBuilder. Additionally, a GraphQLContextContributor interface and its associated instrumentation allow beans to contribute entries directly to the GraphQLContext early in the request lifecycle. The DgsContext class now exposes request data via getRequestData methods for both DataFetchingEnvironment and BatchLoaderEnvironment, and the deprecated logEvent field has been removed.

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/context · high confidence

The \DgsDataLoaderInstrumentationDataLoaderCustomizer\ implementation has been rewritten from Kotlin to Java. This change addresses a null-safety issue inherent in the previous Kotlin implementation, ensuring that data loader instrumentation contexts are correctly applied to \BatchLoaderWithContext\ and \MappedBatchLoaderWithContext\ instances without encountering null-related errors during execution.

graphql-dgs/src/main/java/com/netflix/graphql/dgs/internal · high confidence

The reactive module now uses a dedicated \DefaultDgsReactiveGraphQLContextBuilder\ to construct the GraphQL context, introducing a new \DgsReactiveRequestData\ class that includes the Spring WebFlux \ServerRequest\. This change separates the reactive context-building logic from the core \DgsContext\ class, allowing the reactive layer to handle WebFlux-specific data (like the server request) without coupling it to the base context implementation.

graphql-dgs-reactive/src/main/kotlin/com/netflix/graphql/dgs/reactive/internal · high confidence

The graphql-dgs-client module introduces a new set of Jackson 3-agnostic client interfaces and implementations (DgsGraphQLClient, DgsMonoGraphQLClient, DgsReactiveGraphQLClient, and their concrete classes like DgsRestClientGraphQLClient and DgsWebClientGraphQLClient) that default to Jackson 3. The previous Jackson 2-specific classes (CustomGraphQLClient, CustomMonoGraphQLClient, GraphQLClient, GraphQLResponse, and GraphQLRequestOptions) are now deprecated and marked for removal, with users directed to migrate to the new Dgs\* equivalents to ensure compatibility with future Jackson upgrades.

graphql-dgs-client/src/main/kotlin · high confidence

The federation resolver now validates that @DgsEntityFetcher methods accept only Map or DgsDataFetchingEnvironment arguments, throwing InvalidDgsEntityFetcher if not. It supports DgsDataFetchingEnvironment as a second argument, parses custom scalars in \_entities representations, and handles Mono/CompletionStage return types. Errors from entity fetchers are now properly unwrapped and processed via the configured exception handler, with null returns generating error messages.

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/federation · high confidence

The framework now provides more specific exception types for validation errors, including \DataFetcherInputArgumentSchemaMismatchException\ and \DataFetcherSchemaMismatchException\ for schema mismatches, \DgsMissingCookieException\ for missing cookies, and \DgsDataLoaderInstrumentationException\ for invalid data loader types. The \DefaultDataFetcherExceptionHandler\ has been refactored to unwrap \CompletionException\ and \InvocationTargetException\ before processing, ensuring that the root cause is correctly identified and logged. It also supports configurable log levels for \DgsException\ instances and improves Spring Security exception handling by checking for \AccessDeniedException\ availability at runtime. Several existing exceptions like \DgsEntityNotFoundException\ and \DgsInvalidInputArgumentException\ now extend \DgsException\ to provide consistent error type mapping.

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/exceptions · high confidence

The diagnostics module now provides Spring Boot failure analyzers that produce clearer, user-friendly error messages during application startup. If the required DgsJsonMapper bean is missing, users will see a specific suggestion to add either the Jackson 3 databind library or the graphql-dgs-jackson2 dependency. Additionally, GraphQL schema validation errors are now reported with a formatted list of specific issues, making it easier to identify and fix schema problems.

graphql-dgs-spring-graphql/src/main/kotlin/com/netflix/graphql/dgs/diagnostics · high confidence

This change introduces several internal improvements within the DGS framework's utility layer. DataLoader naming is now handled by a new DataLoaderNameUtil that automatically generates names based on the class simple name when the annotation specifies generation. A new SelectionSetUtil has been added to parse GraphQL selection sets into path lists. Multipart file handling has been refined: MultipartFileSerializer now explicitly passes the MultipartFile class to its base serializer, and MultipartVariableMapper now throws specific VariableMappingException instances instead of generic RuntimeExceptions for clearer error reporting. Additionally, the legacy TimeTracer.logTime method is deprecated in favor of Kotlin's standard measureTimedValue, and the removed DgsComponentUtils class indicates a shift away from manual CGLib proxy handling.

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/internal/utils · high confidence

The graphql-dgs-json-api module now provides the DgsJsonMapper interface, a stable contract for JSON serialization and deserialization that decouples the framework from specific Jackson implementations. This allows underlying JSON processing libraries to be swapped (e.g., across Jackson major versions) without breaking existing code, while also exposing a JsonPath configuration for response parsing. The change is accompanied by the addition of a dependencies.lock file to manage version constraints for libraries such as json-path, Kotlin stdlib, and JMH.

graphql-dgs-json-api · high confidence

The \graphql-dgs-extended-scalars\ and \graphql-dgs-spring-boot-micrometer\ modules now include \module-info.java\ files, formally declaring their Java module structure. The extended scalars module exports its auto-configuration to Spring beans, while the Micrometer module exports its metrics package and opens its Micrometer sub-package to Spring beans, enabling proper module-path integration for these components.

graphql-dgs-extended-scalars/src/main/java, graphql-dgs-spring-boot-micrometer/src/main/java · high confidence

The error-types module now exposes new error classifications, including a dedicated CONFLICT error for mutations and a separate TOO\_MANY\_REQUESTS detail (split from ENHANCE\_YOUR\_CALM), alongside a new SERIALIZATION\_ERROR for scalar serialization failures. The core TypedGraphQLError class has been refactored to support Jackson serialization via @JsonCreator, properly exposes the errorType in its specification output, and implements consistent equals/hashCode methods. Additionally, the module now includes a module-info.java file for JPMS support and updated GraphQL schema definitions reflecting these changes.

graphql-error-types/src · high confidence

The WebMVC GraphQL interceptor has been rewritten to implement Spring GraphQL's \WebGraphQlInterceptor\, replacing the previous implementation. This change introduces a new configuration property, \webmvc.asyncdispatch.enabled\, which allows users to control whether GraphQL requests are processed asynchronously or synchronously; when disabled, the interceptor blocks on the response to ensure synchronous dispatch. The updated interceptor also ensures that the \DataLoaderRegistry\ is properly closed after request completion and integrates with \GraphQLContextContributors\ to build the DGS context using the original servlet request attributes.

graphql-dgs-spring-graphql/src/main/kotlin/com/netflix/graphql/dgs/springgraphql/webmvc · high confidence

The DGS Micrometer module has been refactored to use a new metrics model defined in the \DgsMetrics\ enum, introducing specific metric keys (e.g., \gql.query\, \gql.error\, \gql.resolver\, \gql.dataLoader\) and a comprehensive set of tags (e.g., \gql.operation\, \gql.operation.name\, \gql.query.complexity\, \gql.query.sig.hash\). This change replaces the previous instrumentation approach with a new \DgsGraphQLMetricsInstrumentation\ class that supports query complexity calculation, persisted query tracking, and data loader metrics. Users can now configure these metrics via the \management.metrics.dgs-graphql\ prefix, including settings for enabling/disabling resolver and query metrics, limiting tag cardinality, and customizing tags through \DgsContextualTagCustomizer\, \DgsExecutionTagCustomizer\, and \DgsFieldFetchTagCustomizer\ interfaces. The auto-configuration now wires these components, including a \SpectatorLimitedTagMetricResolver\ for tag cardinality control and a \CacheableQuerySignatureRepository\ for query signature caching.

graphql-dgs-spring-boot-micrometer/src/main/kotlin · high confidence

The internal execution engine has been restructured to improve modularity and support for modern Java/Kotlin features. A new BaseDgsQueryExecutor centralizes query execution logic, while a dedicated DataFetcherInvoker handles method invocation, including support for Kotlin coroutines and automatic wrapping in CompletableFuture for virtual threads. Input object mapping now leverages Spring's ConversionService for more robust type handling, and data loader registration has been refined with a new DefaultDataLoaderOptionsProvider and a programmatic reload controller for development environments.

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/internal · high confidence

The Spring Boot failure analyzer registration has been removed from the graphql-dgs module, as the associated SchemaFailureAnalyzer class is no longer present in this location. This change eliminates the automatic diagnostic reporting for schema-related failures within this specific module, likely to reduce dependencies or as part of a broader architectural shift where this functionality is handled elsewhere.

graphql-dgs/src/main/resources · high confidence

The DGS query executors (both synchronous and reactive) have been rewritten to use Spring GraphQL's ExecutionGraphQlService instead of the previous internal execution path. This change aligns the GraphQLContext behavior with Spring GraphQL, ensures the DataLoaderRegistry is properly closed after each request to prevent resource leaks, and integrates Spring GraphQL's SchemaMappingInspector for schema reporting. Additionally, a new ReloadableGraphQLSource component has been introduced to support runtime schema reloading based on a ReloadSchemaIndicator.

graphql-dgs-spring-graphql/src/main/kotlin/com/netflix/graphql/dgs/springgraphql · high confidence

The internal mechanism for resolving method parameters in @DgsData annotated methods has been refactored to use a pluggable ArgumentResolver chain. This change introduces dedicated resolvers for specific parameter types, including @InputArgument, @Source, DataFetchingEnvironment, and Kotlin suspend functions (Continuation). It also adds support for marking data fetcher methods as 'trivial' to optimize execution and ensures that input arguments are correctly resolved even when the @InputArgument annotation is omitted, relying on parameter names as a fallback.

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/internal/method · high confidence

The Spring GraphQL integration now requires Spring Boot 4 or later, enforced by a startup check that throws an error for older versions. Several new configuration properties have been introduced: \dgs.graphql.spring.webmvc.asyncdispatch.enabled\ allows toggling async dispatch for WebMVC, \dgs.graphql.virtualthreads.enabled\ can be set explicitly (or is auto-enabled if Spring's virtual threads are on), and introspection settings are now unified under \dgs.graphql.introspection.enabled\ (mapping to Spring's \spring.graphql.schema.introspection.enabled\). Additionally, the \spring.autoconfigure.exclude\ property is now correctly merged with YAML lists and indexed values, and certain auto-configurations (observation and security) are disabled by default unless explicitly enabled.

graphql-dgs-spring-graphql/src/main/kotlin/com/netflix/graphql/dgs/springgraphql/autoconfig · high confidence

The Gradle wrapper has been upgraded from version 6.7 to 9.7.1. This update introduces stricter distribution integrity checks by adding SHA-256 verification for the downloaded Gradle binary and enabling URL validation. Additionally, new configuration properties have been added to control network behavior, including a 10-second network timeout, retry settings (0 retries with 500ms back-off), and explicit validation of the distribution URL, ensuring more robust and secure dependency downloads during builds.

gradle · high confidence

Added GraphQL schema for union type testing; Added GraphQL schema test fixtures for multiple locations; Added JMH benchmark for DGS GraphQL metrics instrumentation; Added Java test input objects for complex GraphQL argument scenarios; Added Java unit tests for GraphQL client response handling and custom ObjectMapper support; Added comprehensive test coverage for DGS GraphQL client functionality; Added integration tests for example shared components; Added test coverage for DGS Spring GraphQL integration components; Added test examples for bean and field-based DataLoader annotations; Added test fixtures for GraphQL schema parsing in location3; Added test fixtures for Java enum and scalar input handling; Added test input model for scalar deserialization; Added test input objects for Java SortBy functionality; Added test schema for @Source annotation; Added test slices and integration tests for the Spring GraphQL example app; Added tests for Bean Validation size constraints and auto-configuration; Added tests for DGS Micrometer metrics configuration and instrumentation; Added tests for DateRange scalar serialization and deserialization; Added tests for DgsException and DefaultDataFetcherExceptionHandler behavior; Added tests for DgsException log level configuration; Added tests for GraphQL subscription OperationMessage serialization; Added tests for Kotlin coroutines, custom directives, data loader instrumentation, and federation resolver behavior; Added tests for extended scalars auto-configuration and serialization; Added tests for reactive data fetchers in the WebFlux example; Added tests for subscription and time data fetchers; Added unit tests for internal DGS components; New test slice annotations for DGS Spring GraphQL; Updated test schema with extended types and comments.

The DGS framework has been restructured with a new platform BOM (\graphql-dgs-platform\) that centralizes dependency versions, including a security fix for Log4j ([CVE redacted]) by pinning \log4j-to-slf4j\ and \log4j-api\ to 2.26.1. The build system now uses Spring's dependency management plugin and enforces a strict version for \json-path\ (3.0.0). The project has removed the \graphql-dgs-mocking\ module and replaced \javafaker\ with \datafaker\. Additionally, the framework now supports Jackson 3 with backward compatibility for Jackson 2, introducing new modules like \graphql-dgs-json-api\ and \graphql-dgs-jackson2\ to handle JSON serialization, and provides example projects to demonstrate these configurations.

(dependencies) · high confidence

The build configuration in buildSrc now sets the Kotlin version to 2.2.20. This change replaces the previous hardcoded versions for Spring, Spring Boot, Spring Security, GraphQL Java, and GraphQL Java Federation, which have been removed from this file.

buildSrc · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 64 → 67 (+3.5)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 97 → 97 (-0.1)
• Architecture 100 → 99 (-0.7)
• Maturity 55 → 56 (+0.3)
• Readiness 67 → 69 (+1.7)
• Security 62 → 73 (+10.9)
• Performance 100 (new)

• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2

• Duplicated block (16 lines × 2) (graphql-dgs-example-shared/src/main/java/com/netflix/graphql/dgs/example/shared/datafetcher/ConcurrentDataFetcher.java)
• Duplicated block (35 lines × 2) (graphql-dgs-example-shared/src/main/java/com/netflix/graphql/dgs/example/shared/dataLoader/MessageDataLoader.java)
• Duplicated block (6 lines × 2) (graphql-dgs-spring-graphql-example-java-webflux/src/main/java/com/netflix/graphql/dgs/example/reactive/ReactiveSpringGraphQLExampleApp.java)
• Flaky test: com.netflix.graphql.dgs.metrics.micrometer.MicrometerServletSmokeTest.Assert metrics for a successful async response with errors()
• Further sole-owners (lower concentration)
• Inconsistent identification of DataLoaders. getDataLoader takes a Class type, while instrumentation and options providers often rely on a String name. This creates a dual-identity problem for DataLoaders (by Class vs by Name), which can lead to bugs if the name generated does not match the class name or if users mix these approaches.
• Inconsistent method naming for the primary execution operation across client types. Synchronous clients use executeQuery, while reactive clients use reactiveExecuteQuery. This forces developers to remember different method names based on the return type (blocking vs reactive), rather than a unified interface.
• Inconsistent parameter naming for the executor in overloaded methods. The synchronous GraphQLClient interface uses requestExecutor, while the reactive MonoGraphQLClient interface uses requestExecutor as well, but the types differ (RequestExecutor vs MonoRequestExecutor). More critically, the synchronous interface has an overload with requestExecutor but the reactive one does not have a direct equivalent overload structure in the same way, leading to confusion about which executor type to pass when implementing custom clients.
• Low cohesion: DgsGraphQLSourceBuilder (LCOM4 4) (graphql-dgs-spring-graphql/src/main/kotlin/com/netflix/graphql/dgs/springgraphql/DgsGraphQLSourceBuilder.kt)
• No ADRs found
• Off the main sequence: :graphql-dgs-subscription-types
• Off-boarding risk: anonymized user #1

• 4 commits — 4 feature/other, 0 fixes

• (repo) — 2 commits
• (root) — 1 commit
• graphql-dgs-extended-scalars/src — 1 commit

• change: Bump org.slf4j:slf4j-api from 2.0.18 to 2.0.19
• change: Merge pull request #2348 from voidstackloop/feature/extended-scalars-24
• change: Merge pull request #2349 from Netflix/dependabot/gradle/org.slf4j-slf4j-api-2.0.19
• change: feat(extended-scalars): bump graphql-java-extended-scalars to 24.0 and register new scalars

• Containers 0 added · 0 removed · contexts 8 added · 1 removed · edges 5 added · 0 removed

• graphql-dgs
• graphql-dgs-client
• graphql-dgs-reactive
• graphql-dgs-spring-boot-micrometer
• graphql-dgs-spring-graphql
• graphql-dgs-spring-graphql-example-java
• graphql-dgs-spring-graphql-example-java-webflux
• graphql-dgs-subscription-types

• .

• graphql-dgs-client → graphql-dgs-subscription-types (coupling)
• graphql-dgs-reactive → graphql-dgs
• graphql-dgs-spring-boot-micrometer → graphql-dgs
• graphql-dgs-spring-graphql → graphql-dgs (coupling)
• graphql-dgs-spring-graphql → graphql-dgs-reactive

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Netflix/dgs-framework was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.