apollographql/apollo-kotlin

This system is Apollo Kotlin, a multiplatform GraphQL client and compiler that generates type-safe code for Kotlin, Java, and Swift across JVM, Android, iOS, macOS, Linux, JavaScript, and WebAssembly. It provides a runtime for executing GraphQL queries, mutations, and subscriptions with features like incremental delivery, HTTP caching, and normalized caching. The system also includes a Gradle plugin for build-time code generation and a server-side execution engine for handling GraphQL operations.

75 changes.

This period established the foundational structure for Apollo Kotlin v5, introducing the core API, AST manipulation library, and a centralized build system. It focused heavily on comprehensive test coverage for code generation, caching, and network transport, while introducing performance benchmarking infrastructure and deprecating legacy components.

93 changes.

This period focused on the comprehensive development and stabilization of Apollo Kotlin version 5.0.0, introducing major architectural shifts such as a plugin-based compiler, a new interceptor-based runtime, and native network engines for Apple and JavaScript platforms. Significant features included support for GraphQL incremental delivery (@defer/@stream), persistent HTTP caching, and a new debug server for cache inspection, alongside the deprecation of legacy modules like the SQLite cache and external Gradle plugin. The work was heavily supported by extensive test coverage for these new components, including compiler plugins, WebSocket protocols, and multi-platform connectivity monitoring.

27 changes.

This period focused on introducing the new apollo-execution module for server-side GraphQL operations, including support for subscriptions and granular error handling. The compiler was enhanced with a new Kotlin Data Builder infrastructure to provide a fluent API for constructing response data. Extensive test coverage was added to validate these new features, alongside Linux platform support and Gradle plugin updates.

The Apollo Kotlin tooling now includes the public schema definitions and GraphQL operations for the Apollo Federation 2 platform API. This addition enables the Kotlin client to interact with Apollo Studio features such as schema publishing (monolith and subgraph), schema downloading, and operation collection management, while also applying specific nullability directives to align with the Federation 2 specification.

libraries/apollo-tooling/src/main/graphql/platform-api/public · high confidence

New GraphQL schema definitions and query operations have been added to the microbenchmark suite to support performance testing across four distinct domains: calendar (including fragments for items, categories, and providers), conferences (covering sessions, speakers, and venues), pagination (testing cursor-based user lists), and tracks (testing playlist raw tracks). These files provide the necessary schema contracts and query payloads required to benchmark the GraphQL client's parsing and execution performance for these specific data structures.

benchmark/microbenchmark/src/main/graphql · high confidence

The Apollo runtime now includes native implementations for HTTP and WebSocket networking on the wasmJs platform. This adds a browser-based HTTP engine using the Fetch API and a WebSocket engine using the browser's WebSocket API, enabling GraphQL subscriptions and standard requests in WebAssembly environments. The HTTP engine handles request headers, body serialization, and response streaming, while the WebSocket engine supports text and binary messages, though it is limited to browser environments (no Node.js) and does not support custom HTTP headers for WebSocket connections.

libraries/apollo-runtime/src/wasmJsMain · high confidence

The public API now includes dedicated adapter classes for handling Java's \java.util.Optional\ and Guava's \com.google.common.base.Optional\ types. This allows users to seamlessly serialize and deserialize Optional fields in their GraphQL responses using the provided \JavaOptionalAdapter\ and \GuavaOptionalAdapter\ implementations, along with convenience constants for common scalar types (Any, Boolean, Double, Int, String).

libraries/apollo-api-java/api · high confidence

The Apollo runtime now provides extension functions to easily configure the client to use an OkHttp client or call factory for both HTTP and WebSocket network requests. This simplifies setup by allowing users to pass an existing OkHttpClient instance directly to the ApolloClient.Builder, which internally configures the appropriate HTTP and WebSocket engines, while also maintaining deprecated helpers for older WebSocket transport implementations.

libraries/apollo-runtime/src/jvmCommonMain/kotlin/com/apollographql/apollo/network · high confidence

A new benchmark application has been added to monitor app start performance and support microbenchmark testing via Firebase Test Labs. This app includes a Compose-based UI that simulates data loading by parsing a large JSON sample and caching it using Apollo's normalized cache, allowing developers to measure startup metrics and time-to-full-display.

benchmark/app · high confidence

A new benchmark module has been added to the project, providing a dedicated Android application and associated micro/macro benchmark subprojects to measure and monitor Apollo runtime performance. This includes the necessary Gradle build configuration, signing keys, and dependencies on the Apollo runtime and normalized cache to facilitate performance regression testing.

(dependencies) · high confidence

A new benchmark project has been introduced under the benchmark/gradle directory, establishing the necessary infrastructure for performance testing. This includes a version catalog (benchmarks.versions.toml) that defines dependencies for the AndroidX Benchmark Gradle plugin (1.1.1), Moshix KSP (0.14.1), and AndroidX Test Core (1.5.0), alongside a symlink to the standard Gradle wrapper.

benchmark/gradle · high confidence

A new standalone Android Studio project has been added to the benchmark directory to facilitate performance testing. This includes a README file explaining how to run macrobenchmarks and microbenchmarks via Android Studio or the command line, along with symlinks to the root Gradle wrapper scripts to support the build process.

benchmark · high confidence

A new internal utility function has been added to convert HTTP/HTTPS URLs to their corresponding WebSocket (ws/wss) equivalents, providing the necessary infrastructure for WebSocket-based communication such as GraphQL subscriptions.

libraries/apollo-runtime/src/commonMain/kotlin/com/apollographql/apollo/network/internal · medium confidence

This change introduces three distinct additions across the codebase. First, it adds a new Moshi-based data model for the microbenchmark suite, defining Kotlin data classes (such as User, Data, and Query) annotated for JSON serialization to support benchmarking performance. Second, it introduces a new \PersistedQueryManifest\ class and a conversion function within the Apollo compiler, enabling the serialization of operation outputs into a specific persisted query manifest format (version 1). Third, it provides the actual implementation for the default coroutine dispatcher in the concurrent runtime module, mapping it to \Dispatchers.IO\.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/pqm, libraries/apollo-runtime/src/concurrentMain, microbenchmark · high confidence

The Android runtime now includes a \NetworkMonitor\ implementation that observes device connectivity changes using \ConnectivityManager\. This allows the Apollo client to detect online/offline states on Android, provided the app targets API 23 or higher and declares the \ACCESS\_NETWORK\_STATE\ permission in its manifest. If these conditions are not met, the monitor defaults to an always-online behavior.

libraries/apollo-runtime/src/androidMain · high confidence

The Apollo Debug Server now includes platform-specific implementations for Android, enabling it to run on Android devices. This change adds an AndroidManifest.xml and an \ApolloDebugServerInitializer\ to register the server via AndroidX Startup, ensuring it is available early in the application lifecycle. Additionally, a new \Server.android.kt\ implementation uses Android's \LocalServerSocket\ to create a debug endpoint scoped to the app's package name, allowing debug clients to connect via local Unix domain sockets rather than TCP ports.

libraries/apollo-debug-server/src/androidMain · high confidence

The apollo-api module introduces the core runtime types and HTTP/JSON infrastructure required for Apollo Kotlin v5. This includes the \BooleanExpression\ system for evaluating \@include\/\@skip\/\@defer\ directives, the \Optional\ sealed class to distinguish absent from null values, and the \DataBuilder\/\DataMap\ DSL for constructing response objects. It also adds the \DefaultHttpRequestComposer\ (supporting \HttpMethod.Query\, POST caching, and \application/graphql-response+json\), the \DefaultUpload\ builder for file uploads, and the \MapJsonReader\/\MapJsonWriter\ for in-memory JSON processing.

apollo-api · high confidence

The compiler has been refactored to support a new plugin architecture via \ApolloCompilerPlugin\, allowing users to register custom transforms for schemas, executable documents, and IR operations, as well as custom persisted query ID generators. This release deprecates the legacy \DocumentTransform\ and \SchemaListener\ interfaces in favor of the new \ExecutableDocumentTransform\ and \SchemaDocumentTransform\. Additionally, users can now generate Data Builders for Kotlin models via the \generateDataBuilders\ option, and the compiler now supports external schema linking through the \@link\ directive for scalar mappings and Kotlin compiler options.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler · high confidence

The Apollo Debug Server now provides a GraphQL schema definition (schema.graphqls) that allows users to query and inspect Apollo Client instances and their normalized caches. This schema defines types for ApolloClient, NormalizedCache, and Record, enabling developers to retrieve client details, view cache record counts, and inspect individual cache records by key and fields via GraphQL queries.

libraries/apollo-debug-server/graphql · high confidence

This change establishes the foundational repository structure for Apollo Kotlin, introducing the initial project files, build configuration, and documentation. It includes the addition of a comprehensive CHANGELOG.md documenting the v5.2.0 release, which features support for the HTTP QUERY method, empty selection sets, and custom JVM HTTP engines. The repository also adds essential configuration files such as .gitattributes, .gitleaks.toml for security scanning, CODEOWNERS, CONTRIBUTING.md, LICENSE, README.md, ROADMAP.md, and the Gradle wrapper scripts (gradlew, gradlew.bat), alongside a renovate.json for dependency management.

(repo-wide) · high confidence

The Apollo Debug Server now exposes a public API allowing users to register and unregister ApolloClient instances. This enables the debug server to track and inspect specific client connections, facilitating debugging workflows by providing visibility into active clients and their configurations.

libraries/apollo-debug-server/api · high confidence

A new debug server component has been added to the Apollo Kotlin library, enabling developers to inspect the normalized cache of registered ApolloClient instances at runtime. The server exposes a GraphQL API that allows querying registered clients, their associated normalized caches, and the individual records (keys, sizes, and fields) stored within them. This capability is primarily intended to support debugging tools, such as the IntelliJ plugin's cache viewer, by providing a standardized interface to dump and analyze cache state without requiring direct access to internal client structures.

libraries/apollo-debug-server/src/commonMain · high confidence

The \apollo-annotations\ module now includes the \ApolloAdaptableWith\ annotation, available across JVM, JS, Apple, Linux, and WASM platforms. This annotation allows developers to specify a custom adapter class for a type, enabling more flexible data transformation and serialization strategies in Apollo-generated code. The annotation is defined with a \KClass\<\*\>\ parameter pointing to the adapter implementation.

libraries/apollo-annotations · high confidence

The new \apollo-execution\ module provides the core runtime for executing GraphQL documents on the server. It introduces \ExecutableSchema\ as the main entry point for handling requests, supporting queries, mutations, and subscriptions. The module includes a \PreparedRequest\ structure for validated and coerced requests, a \Coercing\ system for handling scalar types (including a new \JsonCoercing\), and support for persisted documents via an \InMemoryPersistedDocumentCache\. It also adds \Instrumentation\ hooks for monitoring execution, \RootResolver\ and \TypeResolver\ interfaces for customizing data fetching, and built-in support for introspection and service capabilities.

libraries/apollo-execution · high confidence

The compiler now includes new internal data models, \ProjectModel\ and \CompilationUnitModel\, which serialize Gradle project paths, service names, schema locations, endpoint configurations, and dependency information to JSON. These models provide the structured metadata required for IDE integration and task dependency tracking, enabling better project analysis and tooling support for Apollo GraphQL services.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/model · high confidence

The \apollo-execution\ module now includes a new execution engine that supports GraphQL subscriptions via a \Flow\<SubscriptionEvent\>\ stream and provides granular error handling through an \OnError\ callback and \ResolveInfo\. This engine introduces core components such as \OperationContext\ for managing field resolution and instrumentation, \Resolver\ and \ResolveInfo\ for field data retrieval, and \GraphQLResponse\ for serializing results. It also includes internal utilities like a minimal \Either\ type for error management and supports fragment execution and argument coercion.

apollo-execution · high confidence

The \apollo-http-cache\ module now provides a persistent, disk-backed LRU HTTP cache for Apollo Kotlin. This allows GET and POST requests to be cached locally, improving performance and enabling offline access. Users can configure the cache directory and size via \ApolloClient.Builder.httpCache()\, and control caching behavior using \HttpFetchPolicy\ (CacheFirst, CacheOnly, NetworkFirst, NetworkOnly) and options like \httpExpireTimeout\ and \httpDoNotStore\. The cache automatically handles cache keys, stale-while-revalidate patterns, and removes entries on transport errors or GraphQL errors for queries.

libraries/apollo-http-cache · high confidence

This change publishes the public API surface for the new \apollo-execution\ library, making the core execution components available for use. The exposed API includes the \ExecutableSchema\ builder for configuring schemas, resolvers, and error handling, as well as the \PreparedRequest\ class which allows executing GraphQL operations with pre-parsed fragments and arguments. It also exposes data models like \GraphQLRequest\ and \GraphQLResponse\, type coercion interfaces (\Coercing\), and instrumentation hooks (\Instrumentation\, \FieldCallback\, \OperationCallback\), enabling developers to build custom GraphQL execution pipelines.

libraries/apollo-execution/api · high confidence

The \apollo-ast\ module is now available as a standalone library, providing core functionality to parse GraphQL documents, manipulate their Abstract Syntax Tree (AST), and validate schemas and operations. This includes public APIs for parsing (\parseAsGQLDocument\, \toExecutableDocument\), schema validation (\Schema\, \SchemaValidationOptions\), and AST transformation (\GQLNode.transform\). The library also introduces support for advanced GraphQL features such as \@link\ directive handling for foreign schemas, schema coordinates, and fragment arguments, along with a comprehensive set of validation issues (e.g., \FragmentCycle\, \DirectiveRedefinition\) to provide detailed error reporting for GraphQL documents.

libraries/apollo-ast · high confidence

The Apollo runtime now includes a dedicated HTTP engine implementation for Apple platforms (iOS, macOS, etc.) located in the \appleMain\ source set. This new \AppleHttpEngine\ utilizes \NSURLSession\ with an ephemeral session configuration by default, ensuring that network caches and credentials are not persisted across app launches. It supports streaming data responses and handles HTTP methods including GET, POST, and QUERY, providing a native networking layer for Apple targets that replaces or supplements previous platform-agnostic or other platform-specific implementations.

libraries/apollo-runtime/src/appleMain/kotlin/com/apollographql/apollo/network/http · high confidence

The Apollo runtime now exposes the \ApolloInterceptor\ interface, allowing users to insert custom logic into the GraphQL request/response pipeline. This includes a new \InsertionPoint\ enum (e.g., \BeforeNetwork\, \BeforeCache\) to control where custom interceptors are placed in the chain. The diff also introduces built-in interceptors: \AutoPersistedQueryInterceptor\ for handling persisted query negotiation and \NetworkInterceptor\ for routing requests to the appropriate network transport based on operation type (Query, Mutation, Subscription).

libraries/apollo-runtime/src/commonMain/kotlin/com/apollographql/apollo/interceptor · high confidence

The Apollo compiler now includes a new Java code generation backend, allowing users to generate Java source files alongside or instead of Kotlin. This change introduces the \JavaCodegen\ module and associated builders (such as \DataBuilderBuilder\ and \JavaOptionalAdapterBuilder\) that produce Java classes using JavaPoet, including support for data builders, optional adapters (Java and Guava), and schema types.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/codegen/java · high confidence

The Java code generator in apollo-compiler now generates code for GraphQL @oneOf input objects. This includes generating an \assertOneOf\ utility method to enforce the constraint that exactly one field is set, and applying this validation within the constructors of generated Input Object model classes.

apollo-compiler · high confidence

Apollo Runtime now supports the Linux platform (linuxX64 and linuxArm64) by introducing native HTTP and WebSocket engines. The new DefaultHttpEngine uses Ktor's Curl engine to handle HTTP requests, including support for the QUERY HTTP method, while the new LinuxWebSocketEngine provides WebSocket connectivity using Ktor's WebSocket plugin. An older, deprecated DefaultWebSocketEngine remains in the codebase but is marked for removal in v5.0.0.

libraries/apollo-runtime/src/linuxMain · high confidence

The Apollo runtime now includes native network status monitoring for iOS and macOS. This change introduces an Apple-specific implementation that leverages the Network framework to detect connectivity changes, allowing the client to react to network availability shifts on Apple devices.

libraries/apollo-runtime/src/appleMain/kotlin/com/apollographql/apollo/network · high confidence

The tooling now includes a new set of internal APIs for interacting with the Apollo Platform, enabling schema downloads and uploads via the registry, publishing operations, and tracking field latencies. It also introduces automatic detection of GraphQL specification features (such as OneOf, deprecated input values, and service capabilities) during introspection to ensure compatibility with various server implementations.

libraries/apollo-tooling/src/main/kotlin · high confidence

The HTTP networking layer in the Apollo runtime has been refactored to introduce a new \HttpInterceptor\ chain and several built-in interceptors. This includes \BatchingHttpInterceptor\ for combining multiple GraphQL queries into single HTTP requests to reduce round trips, \LoggingInterceptor\ for debugging requests and responses at various verbosity levels, \HeadersInterceptor\ for adding custom headers, and \ApolloClientAwarenessInterceptor\ for sending client identification headers. The \HttpEngine\ interface now wraps platform-specific implementations, and \HttpInfo\ is available in the execution context to expose request timing and status details.

libraries/apollo-runtime/src/commonMain/kotlin/com/apollographql/apollo/network/http · high confidence

The compiler now generates Kotlin Data Builders, introducing a new DSL-based API for constructing GraphQL response data. This change adds new code generation components (AdaptBuilder, DataBuilderBuilder, DataMapBuilder, FragmentExtensionBuilder, ResolverBuilder) that produce builder classes, data maps, and adapter logic, enabling users to build typed data structures from GraphQL responses using a fluent builder pattern.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/codegen/kotlin/builders · high confidence

This change introduces several new Kotlin and shell scripts to streamline development workflows. The \bump-kotlin-nightlies.main.kts\ script automates the process of updating Kotlin and KSP versions in the version catalog, rebasing the \kotlin-nightlies\ branch, updating package locks, and triggering the pull-request build workflow. A new \run-firebase-benchmarks.main.kts\ script executes micro-benchmarks on Firebase Test Lab and writes results to a JSON file, while \upload-benchmarks.main.kts\ sends these results (along with native and JMH benchmark data) to Datadog and updates the relevant GitHub issue. Additionally, \collect-diagnostics.main.kts\ packages diagnostic reports and core dumps for CI artifacts, \update-repo.main.kts\ handles version updates across properties, catalogs, and documentation, and \update-package-locks.sh\ provides a shell-based alternative for refreshing Gradle package locks.

scripts · high confidence

The Apollo runtime now includes a configurable RetryStrategy that allows requests to be automatically retried based on network state and error types, improving resilience for offline scenarios and transient network failures. Additionally, support for the @defer and @stream directives (incremental delivery v0.2) has been implemented, enabling clients to receive partial GraphQL responses in multiple parts. The runtime also introduces a new NetworkMonitor interface that exposes network state via StateFlow, facilitating better connectivity-aware behavior.

apollo-runtime · high confidence

The runtime now supports incremental delivery protocols (draft v0.1 and v0.2) for the \@defer\ and \@stream\ directives, allowing queries to return data in multiple chunks rather than waiting for a single complete response. This is enabled by new internal components including \MultipartReader\ for parsing multipart body parts, \IncrementalResultsMerger\ implementations to merge incremental payloads, and protocol definitions in \IncrementalDeliveryProtocol\. Additionally, the runtime now recognizes the \application/graphql-response+json\ content type and handles multipart responses via \multipartBodyFlow\, ensuring that streaming and deferred data is correctly assembled for the client.

libraries/apollo-runtime/src/commonMain/kotlin/com/apollographql/apollo/internal · high confidence

The Apollo Gradle plugin now allows users to register multiple custom compiler plugins using the Java ServiceLoader mechanism. This change introduces the \ApolloCompilerPlugin\ and \ApolloCompilerPluginProvider\ interfaces, enabling developers to implement custom logic such as generating unique operation IDs or modifying the compilation environment. A sample implementation demonstrates how to provide a custom plugin that transforms operation descriptors into custom IDs, enhancing the compiler's extensibility for advanced use cases.

libraries/apollo-gradle-plugin/testProjects/operationIdsWithIsolation/apollo-compiler-plugin · high confidence

This entry defines the public API for the Apollo HTTP cache library, exposing classes and functions for managing HTTP response caching. It includes the \ApolloHttpCache\ interface and its \DiskLruHttpCache\ implementation for storing responses, the \CachingHttpInterceptor\ for intercepting network requests, and the \HttpCache\ utility class which provides extension functions to configure the \ApolloClient.Builder\ with cache settings and to inspect response origins. The \HttpFetchPolicy\ enum is also exposed, allowing users to select between \CacheOnly\, \NetworkOnly\, \CacheFirst\, and \NetworkFirst\ strategies for their queries.

libraries/apollo-http-cache/api · high confidence

This change introduces the initial public API signature files for the \apollo-testing-support\ module, establishing the stable contract for testing utilities. The exposed API includes \MockServer\ and \WebsocketMockRequest\ for simulating server interactions, along with \MapTestNetworkTransport\ and \QueueTestNetworkTransport\ for controlling network responses in tests. Additionally, extension functions on \ApolloClient\ are defined to allow enqueuing and registering test responses and network errors, enabling developers to write deterministic tests for their GraphQL clients.

(repo-wide) · high confidence

The public API surface for the normalized cache library is now explicitly defined in the \apollo-normalized-cache-api.api\ and \apollo-normalized-cache-api.klib.api\ files. This establishes the stable contract for core caching components, including \MemoryCache\, \CacheHeaders\, \CacheKey\, and various \CacheResolver\ implementations, ensuring consistent binary compatibility across JVM and Kotlin multiplatform targets.

libraries/apollo-normalized-cache-api/api · high confidence

The public API surface for the normalized cache library is now explicitly defined, exposing the \ApolloStore\ interface for direct cache read/write operations (including optimistic updates and key-based notifications via \ALL\_KEYS\), the \CacheInfo\ class for inspecting cache hit/miss details in responses, and extension functions on \ApolloClient.Builder\ and \MutableExecutionOptions\ to configure caching behavior such as fetch policies, cache headers, and miss logging.

libraries/apollo-normalized-cache/api · high confidence

The Apollo Gradle plugin now executes its code generation tasks in a separate classloader via the new \apollo-gradle-plugin-tasks\ module. This architectural change isolates the compiler and its dependencies from the main build script classpath, preventing classpath pollution and allowing compiler plugins to load without conflicts. For users, this improves build stability and compatibility, particularly in complex multi-module setups or when using newer Gradle features like isolated projects.

libraries/apollo-gradle-plugin · high confidence

A new 'build-logic' JVM project has been added to centralize shared build logic and buildscript dependencies. This change allows the main build and composite builds to share common configuration, eliminating the need to specify dependency versions in each individual module's plugins block.

build-logic · high confidence

The Kotlin code generation logic in the compiler has been reorganized from monolithic files into a set of specialized helper modules (e.g., AdapterCommon, DataClass, KDoc, NamedType). This refactoring improves maintainability and clarity of the generated code structure without changing the external API or behavior for users.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/codegen/kotlin/helpers · high confidence

A change to existing behaviour in libraries/apollo-normalized-cache-sqlite/sqldelight — 4 commits, 1 file.

libraries/apollo-normalized-cache-sqlite/sqldelight · medium confidence · unverified

The Apollo runtime now includes platform-specific implementations for the JavaScript target. A new default coroutine dispatcher is provided using \Dispatchers.Default\, and a utility to detect whether the code is running in a Node.js environment has been added. These changes ensure correct coroutine scheduling and environment detection for JavaScript users.

libraries/apollo-runtime/src/jsMain/kotlin/com/apollographql/apollo/internal · high confidence

The public API dump for the SQLite normalized cache library now includes the watchosDeviceArm64 target, in addition to existing iOS, macOS, and tvOS platforms. This enables developers to use the SqlNormalizedCache and SqlNormalizedCacheFactory classes on Apple Watch devices running on the ARM64 architecture.

libraries/apollo-normalized-cache-sqlite/api · high confidence

A new file, android-sdk-preview-license, has been added to the android-licenses directory containing the SHA-1 hash (84831b9409646a918e30573bab4c9c91346d8abd) for the Android SDK Preview license. This allows the build system to automatically accept the preview license during CI or automated builds.

android-licenses · high confidence

The \apollo-api\ module has been restructured for version 5, moving all source files under the \lib\ directory and introducing several API changes. The \ApolloRequest\ builder now supports setting a custom URL, enabling \onError\ callbacks, and configuring enhanced client awareness. \ApolloResponse\ gains a \toString()\ implementation for easier debugging. JSON parsing behavior changes include support for \ignoreUnknownKeys\ to skip unexpected fields and the removal of nesting limitations (which may cause OutOfMemory errors on deeply nested JSON). Platform-specific fixes address NSURL encoding on recent Apple OS versions, and performance improvements optimize fragment type condition checks and JSON number type detection.

libraries/apollo-api · high confidence

This change introduces several internal compiler components and validation rules. A new ApolloExecutableDocumentTransform handles adding required fields (like \_\_typename and key fields) to operations and fragments based on configuration. The DefaultApolloCompilerRegistry now supports registering multiple compiler plugins with explicit ordering (Before/After) to manage transformation pipelines. Validation logic has been updated to check for capitalized field names that clash with generated models, ensure inline fragments have type conditions, detect reserved enum value name clashes, and prevent unsupported conditional fragments (@include/@skip/@defer) in response-based models. Additionally, legacy operation ID generation is deprecated in favor of the new registry-based approach, and utility classes for string inflection and Java/Kotlin reserved word escaping are added.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/internal · high confidence

The build-logic module has been rewritten in Kotlin to support Kotlin 2.0, introducing a new multiplatform target configuration (kmp.kt) that adds Wasm.js and Linux ARM64 targets alongside existing platforms. The Android configuration (Android.kt) now uses version catalogs for SDK versions and conditionally enables multiDex. Publishing is centralized via the Librarian plugin (api.kt), which handles ABI validation, signing, and metadata generation. A new WebSocket echo server (websocket\_server/) is integrated as a Gradle Build Service to support integration tests, and test execution is optimized by disabling non-host native tests and aggregating results across the project.

build-logic/src · high confidence

The legacy WebSocket classes in the \com.apollographql.apollo.network.ws\ package (including \GraphQLWsProtocol\, \WebSocketNetworkTransport\, and \WsProtocol\) are now marked as deprecated since version 5.0.0. These files serve as a compatibility layer that delegates to the new implementation in \com.apollographql.apollo.network.websocket\. Users should migrate their WebSocket subscriptions and connections to the new package to avoid errors in future versions.

libraries/apollo-runtime/src/commonMain/kotlin/com/apollographql/apollo/network/ws · high confidence

The apollo-api-java module, which previously provided Java-specific support libraries including adapters for Guava and Java 8 Optionals, has been deprecated and moved to the Apollo Galaxy. Users relying on this module for compiling Java models or handling Optional types should migrate to the Apollo Galaxy.

libraries/apollo-api-java · high confidence

The \com.apollographql.apollo.external\ Gradle plugin has been removed and replaced with a tombstone that throws an error directing users to migrate to the \apollo-gradle-plugin\ and the \com.apollographql.apollo\ plugin ID. This change reflects the plugin's switch to classloader isolation, which no longer requires R8-based dependency relocation. The \apollo-gradle-plugin-external\ artifact now serves solely as a Maven relocation redirect to the main plugin.

libraries/apollo-gradle-plugin-external · high confidence

The legacy normalized cache implementation in the \apollo-normalized-cache\ module is now deprecated and scheduled for removal in version 5.0.0. Users are directed to migrate to the new Normalized Cache library at https://github.com/apollographql/apollo-kotlin-normalized-cache. This change affects core configuration methods like \normalizedCache()\ and \store()\, as well as query watching via \watch()\, all of which now carry deprecation warnings. The underlying \ApolloStore\, \ApolloCacheInterceptor\, and \WatcherInterceptor\ classes remain present to support existing functionality during the transition period but are marked for future removal.

apollo-normalized-cache, libraries/apollo-normalized-cache-api · high confidence

The \apollo-normalized-cache\ module, which provided \ApolloStore\ and cache interceptors like \CacheOnlyInterceptor\ and \NetworkFirstInterceptor\, is now deprecated as of version 5.0.0. Users are directed to migrate to the new Normalized Cache repository. The module's public API remains available but is marked with deprecation annotations to signal that it is no longer the recommended approach for caching in Apollo Kotlin.

libraries/apollo-normalized-cache · high confidence

The normalized cache API now includes a new internal CacheBatchReader that correctly merges data when GraphQL queries use include directives, resolving issues where data might be duplicated or lost in complex selection sets. Additionally, the logic for evaluating fragment type conditions has been optimized to check against a set rather than a list, improving performance during cache reads.

apollo-normalized-cache-api · high confidence

The Apollo Gradle plugin now includes the full module path in error messages when duplicate types are detected across multi-module projects, making it easier to identify the source of the conflict.

libraries/apollo-gradle-plugin/testProjects/multi-modules-duplicates/node1/impl, libraries/apollo-gradle-plugin/testProjects/multi-modules-duplicates/node2/impl · low confidence

The internal GraphQL schema and operations for the Apollo platform API have been updated to include new fields and mutations. The schema now extends types with nullability directives (e.g., \@semanticNonNullField\) to clarify data contracts. New operations include \RegisterOperations\ for submitting operation manifests, \FieldLatencies\ for retrieving performance metrics, and \TrackApolloKotlinUsage\ for telemetry. The schema also exposes detailed account information such as billing insights, subscription status, and graph management capabilities.

libraries/apollo-tooling/src/main/graphql/platform-api/internal · high confidence

The apollo-mpp-utils module now includes an internal multiplatform utility for retrieving the current time in milliseconds. This change adds platform-specific implementations for JVM, Apple, JS, Linux, and WasmJS targets, replacing the previous expect/actual declaration with concrete logic (e.g., using System.currentTimeMillis on JVM, NSDate on Apple, and clock\_gettime on Linux). This utility is intended for internal use within the Apollo client, specifically to support absolute timestamp handling in HttpInfo, and is not intended for direct public consumption.

libraries/apollo-mpp-utils · high confidence

The JVM-specific HTTP engine implementation has been updated to support HTTP response caching via OkHttp's cacheUrlOverride, allowing responses to be served from the cache when available. Additionally, the engine now supports the HTTP QUERY method, enabling GraphQL clients to send requests using the GET-like QUERY verb with a request body, in addition to the existing GET and POST methods. Users can now check if a response was served from the HTTP cache using the new isFromHttpCache property on ApolloResponse.

libraries/apollo-runtime/src/jvmCommonMain/kotlin/com/apollographql/apollo/network/http · high confidence

The JVM WebSocket engine has been restructured to allow the use of custom HTTP engines without requiring OkHttp as a hard dependency. The new \JvmWebSocketEngine\ accepts a factory function for the WebSocket factory, enabling lazy initialization and decoupling from specific HTTP client implementations. The previous \DefaultWebSocketEngine\ in the \com.apollographql.apollo.network.ws\ package is now deprecated in favor of the new API in \com.apollographql.apollo.network.websocket\, facilitating a smoother migration path for users who need to integrate alternative HTTP libraries.

libraries/apollo-runtime/src/jvmCommonMain/kotlin/com/apollographql/apollo/network/websocket · high confidence

Apple (iOS/macOS) clients now use a native WebSocket engine based on NSURLSession instead of the previous implementation. This change introduces specific handling for connection lifecycle events and ensures that ApolloWebSocketClosedException is thrown when the connection is closed, providing more accurate error reporting for WebSocket disconnections on these platforms.

libraries/apollo-runtime/src/appleMain/kotlin/com/apollographql/apollo/network/websocket · high confidence

The runtime introduces a new \ApolloCall\ class that binds an \ApolloRequest\ with its \ApolloClient\, providing a fluent API to configure requests (e.g., \url\, \httpMethod\, \ignoreUnknownKeys\, \retryOnError\, \extensions\, and experimental \onError\). This class exposes \execute()\ for single-response scenarios and \toFlow()\ for streaming multiple responses (subscriptions, \@defer\). Additionally, new execution context elements are added: \AutoPersistedQueryInfo\ to track APQ hits, \ConcurrencyInfo\ to expose the client's dispatcher and scope for cache writes, \CacheDumpProviderContext\ for internal cache debugging, and a deprecated \ConflateResponsesContext\ for migration from v3 behavior.

libraries/apollo-runtime/src/commonMain/kotlin/com/apollographql/apollo · high confidence

The Apollo AST module has been replaced with a new implementation that includes a custom GraphQL lexer, an extensions merger for schema composition, and a rewritten field-merging validation algorithm. This change introduces support for new schema features such as the \@defer\ directive (with label validation), \@catch\ and \@catchByDefault\ directives, \@requiresOptIn\, \@targetName\, and \@oneOf\. It also adds support for fragment arguments, directives on directive definitions, and service capabilities via the introspection reader. The new engine optimizes performance by skipping unnecessary \@defer\ walks and indexing field definitions, while enforcing stricter validation rules for deprecation reasons and field merging.

apollo-ast · high confidence

The JavaScript runtime now uses new, native implementations for HTTP and WebSocket networking. The new DefaultHttpEngine uses the browser's native fetch API with proper timeout handling and supports the QUERY HTTP method, while the new WebSocketEngine provides a unified implementation for both Node.js (using the 'ws' library) and browsers, allowing headers to be passed in Node environments. The previous deprecated WebSocket implementation remains available but is marked for removal in Apollo 5.0.

libraries/apollo-runtime/src/jsMain/kotlin/com/apollographql/apollo/network · high confidence

The Kotlin code generation logic has been refactored into a new internal structure within the compiler. This change introduces dedicated classes for managing code generation files (\CgFile\), contexts (\KotlinContext\, \KotlinSchemaContext\, \KotlinOperationsContext\), and output (\KotlinOutput\), alongside a central \KotlinResolver\ for type resolution and a \KotlinSymbols\ object for API references. This restructuring provides the foundation for the compiler to generate Kotlin source code using KotlinPoet, supporting features like inline classes, enum generation strategies, and data builders.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/codegen/kotlin · high confidence

The public API surface for the \apollo-gradle-plugin-external\ module has been cleared, as evidenced by the new API dump file containing no declarations. This indicates that the module no longer exposes any public symbols for external consumption, likely due to internal refactoring or the removal of public interfaces.

libraries/apollo-gradle-plugin-external/api · high confidence

The compiler's code generation logic has been restructured to centralize and standardize how class names, package paths, and identifiers are determined. A new \ClassNames\ object consolidates references to core API types (such as \DataBuilder\, \QueryData\, and \JsonReader\) to improve ProGuard/R8 compatibility, while \Identifiers\ centralizes string constants used in generated code. The \LayoutImpl\ class now serves as the single source of truth for naming conventions, handling schema type mapping, operation naming (with optional semantic suffixes), and field decapitalization. Supporting utilities like \Flatten\ manage model group traversal and name clash resolution, and new helper functions in \data-builders-utils.kt\ and \fieldPolicyArgs.kt\ standardize the generation of builder names and field policy key arguments.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/codegen · high confidence

The Kotlin code generation logic for operations, fragments, and models has been restructured into a new set of dedicated builder classes (CompiledSelectionsBuilder, FragmentBuilder, ModelBuilder, and various adapter builders). This refactoring introduces a more modular approach to generating Kotlin code, separating concerns for selection sets, fragment definitions, model classes, and JSON adapters. Users will benefit from improved maintainability and potentially better performance in code generation, as the new structure allows for more granular control over the generated code. The changes also include updates to how conditions, arguments, and type conditions are handled during code generation, ensuring consistency and correctness in the generated Kotlin code.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/codegen/kotlin/operations · medium confidence

The Kotlin schema code generation logic has been restructured into a set of dedicated builder classes (such as EnumAsApolloEnumBuilder, EnumAsEnumBuilder, and CustomScalarAdaptersBuilder) located in the schema package. This change introduces a new \ApolloEnum\ sealed interface for enums, which includes a \\_\Known\ interface to distinguish build-time known values from unknown ones, and generates a \\\_CustomScalarAdapters\ object to manage custom scalar adapter registration at build time. These builders now handle the generation of schema types, scalars, and adapters using a more modular approach.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/codegen/kotlin/schema · high confidence

The WebSocket subscription implementation has been restructured to use a new \WsProtocol\ interface, separating protocol-specific logic (such as \GraphQLWsProtocol\ and the deprecated \SubscriptionWsProtocol\) from the core transport. This change introduces dedicated message types (\ClientMessage\, \ServerMessage\) and a \SubscriptionParser\ interface to handle incoming data, while the \WebSocketNetworkTransport\ now relies on a \WebSocketEngine\ for low-level connection management. Users benefit from a cleaner architecture that supports multiple WebSocket protocols and easier customization of message parsing and connection behavior.

libraries/apollo-runtime/src/commonMain/kotlin/com/apollographql/apollo/network/websocket · high confidence

The internal compiler IR layer has been restructured to improve code organization and performance. New internal helper functions for collection operations (intersections, unions, pairs, combinations) and type-set logic have been added to support complex schema analysis. The core IR generation is now handled by dedicated builders for operations and schemas, which manage type resolution, fragment usage caching, and the construction of intermediate representation objects for scalars, enums, interfaces, and objects. This refactoring consolidates logic previously scattered across the compiler, providing a cleaner foundation for code generation features like fragment arguments and error handling.

libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/ir · medium confidence

The 'themes/meteor' directory, which was previously managed as a Git submodule, has been removed from the repository. This change eliminates the external dependency on the separate submodule repository for this specific theme, simplifying the project's version control structure.

themes · high confidence

The test projects for the Apollo Gradle Plugin have been restructured, with all files moved under the \lib\ directory. This change updates the file paths for various test scenarios, including deprecation warnings, executable schema files, Gradle and Kotlin plugin version tests, Kotlin JVM source sets, multi-module configurations (custom scalars, diamond dependencies, transitive dependencies, and duplicates), multiplatform support, operation registration, and test source sets. Users should be aware that the internal structure of these test projects has changed, which may affect how they are referenced or built within the plugin's test suite.

(repo-wide) · high confidence

The internal testing components, including \QueueTestNetworkTransport\, \MapTestNetworkTransport\, and their associated extension functions, have been moved to a new unpublished module named \apollo-testing-support\. This change also introduces deprecation errors for the old \MockServer\ and \WebsocketMockRequest\ classes, directing users to the new module coordinates for testing without a mock server.

libraries/apollo-testing-support · high confidence

The \apollo-normalized-cache-sqlite\ module, which provided a \NormalizedCache\ implementation backed by SQLite for persisting data across app restarts on Android, Apple, and JVM platforms, is now deprecated as of version 5.0.0. The codebase in this location has been updated to mark \SqlNormalizedCacheFactory\ and related classes with deprecation annotations, directing users to migrate to the new Normalized Cache repository. While the SQLite persistence logic remains functional in this release, it is no longer the recommended approach for new projects.

libraries/apollo-normalized-cache-sqlite · high confidence

The Gradle plugin's internal tooling model has been updated to replace deprecated fields with their new counterparts: \projectName\ is replaced by \projectPath\, and \upstreamProjects\ is replaced by \upstreamProjectPaths\. Additionally, the \DefaultServiceTelemetryData\ class now includes new telemetry fields such as \generateKotlinModels\, \languageVersion\, \addJvmOverloads\, \generateAsInternal\, \generateFragmentImplementations\, \generateQueryDocument\, \generateSchema\, \generateOptionalOperationVariables\, \generateDataBuilders\, \generateModelBuilders\, \generateMethods\, \generatePrimitiveTypes\, \generateInputBuilders\, \nullableFieldStyle\, \decapitalizeFields\, \jsExport\, \addTypename\, \flattenModels\, \generateApolloMetadata\, and \usedOptions\. The deprecated fields \warnOnDeprecatedUsages\ and \fieldsOnDisjointTypesMustMerge\ are now marked as deprecated in favor of \issueSeverities\.

apollo-gradle-plugin · high confidence

The base introspection query used by Apollo Tooling has been updated to reflect the October 2021 GraphQL specification and subsequent proposals. This change ensures that introspection results now include fields such as \description\ for types and directives, \isDeprecated\ and \deprecationReason\ for fields and enum values, and \args(includeDeprecated: true)\ for input values. These updates allow the tooling to accurately capture deprecation status and descriptions from servers that support these newer specification features, improving the fidelity of schema analysis and documentation generation.

libraries/apollo-tooling/src/main/resources · high confidence

The documentation site now features a refreshed visual identity, including a new Apollo logo and updated CSS styles for syntax highlighting (Prism), layout, and theming. This change aligns the documentation appearance with the updated branding and ensures consistent styling across light and dark modes.

dokka · high confidence

The tooling now includes an updated GraphQL introspection schema definition (schema.graphqls) and a new pre-introspection query (pre-introspection.graphql) that retrieves all supported types to improve compatibility with servers like GitHub's API. Additionally, extra.graphqls introduces Apollo-specific schema extensions for nullability handling, aligning with the 4.0.0-beta.3/RC.1 version updates.

libraries/apollo-tooling/src/main/graphql/graphql · high confidence

The parser test fixtures in \libraries/apollo-ast/test-fixtures/parser\ have been reorganized and expanded to validate new parsing capabilities. The parser now supports fragment arguments (e.g., \...foo(a: 42)\), service capabilities (e.g., \capability com.example\), and anonymous operations. Additionally, the parser behavior for empty selection sets has been updated to allow them by default, while still enforcing strict rules for invalid syntax such as empty type extensions and unqualified capability names.

libraries/apollo-ast/test-fixtures/parser · high confidence

The public API dump files for the apollo-annotations library have been updated to reflect the current set of annotations, including ApolloAdaptableWith, ApolloDeprecatedSince (with its Version enum entries up to v5\_1\_1), ApolloExperimental, ApolloInternal, ApolloPrivateEnumConstructor, and ApolloRequiresOptIn. This ensures the declared binary interface matches the actual implementation across supported platforms.

libraries/apollo-annotations/api, libraries/apollo-ast/api · high confidence

The public API for the Android SQL normalized cache has been updated to expose new constructor overloads on SqlNormalizedCacheFactory. These changes allow developers to pass a custom SupportSQLiteOpenHelper.Factory, a callback function, a flag for encryption support, and a windowSizeBytes parameter, enabling more flexible configuration of the SQLite driver and supporting features like SQLCipher data encryption.

libraries/apollo-normalized-cache-sqlite/api/android · high confidence

The public API dump for the Apollo Runtime library has been updated to reflect the v5 interface changes. This includes new configuration options on \ApolloClient.Builder\ such as \failFastIfOffline\, \sendEnhancedClientAwareness\, and \httpBatching\, as well as new methods on \ApolloCall\ like \onError\ and \extensions\. The API also exposes new types for incremental delivery (\IncrementalDeliveryProtocol\), retry strategies (\RetryStrategy\), and WebSocket protocols, alongside the \ApolloInterceptor.InsertionPoint\ enum for controlling interceptor order.

libraries/apollo-runtime/api · high confidence

The internal WebSocket implementation has been restructured to allow subscriptions to connect to different server URLs and use custom HTTP headers on a per-request basis. This is achieved by introducing a \WebSocketPool\ that manages connections keyed by URL and headers, and an \OperationListener\ interface to handle response events. The \SubscribableWebSocket\ class now handles the lifecycle of individual connections, including ping/pong keep-alives and idle timeouts, while ensuring thread-safe access to the underlying WebSocket engine. This change enables interceptors to modify the WebSocket URL and headers for specific requests, providing greater flexibility for multi-tenant or dynamic routing scenarios.

libraries/apollo-runtime/src/commonMain/kotlin/com/apollographql/apollo/network/websocket/internal · high confidence

The Apollo Gradle plugin now correctly respects the \allowDirectivesOnDirectives\ configuration option. This fix ensures that GraphQL schemas containing directives applied to other directives (such as \@testDirective\ on \@testDirective2\) are parsed without errors when this option is enabled, resolving previous issues where such schema structures were incorrectly rejected.

libraries/apollo-gradle-plugin/testProjects/parser-options · medium confidence

The benchmark build logic module now correctly references the project's Gradle wrapper via symlinks for both the \gradle\ directory and the \gradlew\ executable. This change ensures that the benchmark module can properly bootstrap and execute Gradle tasks using the standard wrapper mechanism, resolving previous build failures caused by missing or incorrect wrapper paths.

benchmark/build-logic · high confidence

Add GraphQL test fixtures for Kotlin data builders; Add Swift interop test project with unit test for Kotlin interceptor; Add test projects for schema conversion and fragment dependencies; Added AST benchmark suite for Apollo and GraphQL-Java validation and parsing; Added Android Gradle Plugin 9 test projects; Added GraphQL schema and operations files for multi-module test; Added GraphQL test fixtures for @catch and @catchByDefault directives; Added GraphQL test fixtures for @catch directive behavior; Added GraphQL test fixtures for Star Wars schema; Added JVM tests for @defer with HTTP caching; Added JVM tests for Apollo Client builder, execution context, HTTP caching, and WebSocket retry logic; Added JavaScript-specific GraphQL tests for dynamic JSON reading and mutation compilation; Added KDoc escape validation test; Added Kotlin tests for Data Builder functionality; Added WebSocket integration tests; Added browser-based WebSocket and semantic nullability tests; Added compiler benchmark for IR operations; Added compiler tests for GraphQL keywords and hardcoded arguments; Added end-to-end test infrastructure for @defer with Apollo Router and Apollo Server; Added iOS simulator test module; Added instrumented tests for Android network monitoring; Added integration test for no-runtime JSON request composition; Added integration test suite for Apollo Kotlin runtime; Added integration tests for Apollo Compiler plugin hooks; Added integration tests for the Apollo Debug Server; Added macrobenchmark tests for app startup performance; Added multi-module publishing consumer test project; Added native benchmark tests for Apollo Client performance; Added normalization tests for complex caching scenarios; Added sample server for testing GraphQL subscriptions and websockets; Added service loader registrations for compiler plugin test fixtures; Added termination test for Apollo client lifecycle; Added test coverage for GZIP content encoding; Added test coverage for data builders Kotlin consumer fixtures; Added test coverage for schema package naming; Added test data for custom scalar adapters; Added test fixture for configuration cache validation; Added test fixtures for @defer and @stream directives; Added test fixtures for Gradle configuration cache validation; Added test fixtures for GraphQL introspection variants; Added test fixtures for GraphQL nullability and error-catch directives; Added test for Apollo compiler plugin hook; Added test for JSON parsing out-of-bounds exception; Added test for custom HttpRequestComposer with query document; Added test for custom IR transform plugin flattening; Added test plugin for capitalizing enum values; Added test plugin for schema-transform API; Added test plugin for verifying custom name prefixing in code generation; Added test plugin to verify document transform registration; Added test plugin to verify getter/setter generation; Added test plugin to verify typename interface implementation; Added test project for Android test variants; Added test projects for Gradle configuration cache and lazy schema file support; Added test projects for Gradle plugin build cache and version handling; Added tests for @catch directive in nested GraphQL operations; Added tests for @catch directive support in response-based codegen; Added tests for @catch error handling behavior; Added tests for @defer support with normalized cache and protocol versions; Added tests for @deprecated and @requiresOptIn handling; Added tests for @include and @skip directive handling with variable defaults; Added tests for Apollo Client onError handling; Added tests for Apollo tooling schema download and field insights; Added tests for ApolloClient builder validation and interceptor insertion points; Added tests for Apple HTTP engine configuration; Added tests for GraphQL @oneOf input validation; Added tests for GraphQL schema evolution and cache normalization; Added tests for HTTP caching behavior; Added tests for HTTP interceptor exception handling; Added tests for Kotlin codegen variable handling; Added tests for V0.1 and V0.2 incremental results merging; Added tests for cache normalization with variables and @include directives; Added tests for case-insensitive filesystem handling in GraphQL code generation; Added tests for custom scalar adapters and inline class support; Added tests for empty selection sets in GraphQL queries; Added tests for enum value escaping and safe resolution; Added tests for escaping Java/Kotlin reserved keywords in GraphQL; Added tests for fragment arguments support; Added tests for generated data class methods; Added tests for ignoreUnknownKeys configuration; Added tests for jsExport with WebSocket subscriptions and custom scalars; Added tests for multi-module Data Builder generation; Added tests for multi-module GraphQL code generation and type filtering; Added tests for multi-module GraphQL scalar and fragment handling; Added tests for multipart subscription handling; Added tests for multiple compiler plugin registration and schema code generation; Added tests for network authorization, extensions, and WebSocket transport; Added tests for operation-based model serialization, caching, and parsing; Added tests for operation-based models with interfaces; Added tests for optimistic update rollback behavior; Added tests for optional variable handling with directives; Added tests for response-based code generation models; Added tests for storing JsonNumber in the normalized cache; Added tests for test network transport handlers; Added tests for the Apollo Platform API; Expanded GraphQL validation test coverage for executable queries; Internal testing support module created; New internal test module for HTTP and WebSocket engine implementations; New microbenchmarks for incubating cache and Apollo Store concurrency; Tests for runtime HTTP header handling; Updated merger test fixtures for validation and service capabilities; Updated multi-module custom scalar test project structure; Updated test fixtures for multi-module bad config validation.

The build system now uses a centralized version catalog (gradle/libraries.toml) to manage dependency versions and definitions, replacing scattered version declarations. Repository resolution is also centralized in gradle/repositories.gradle.kts, using Gradle's exclusiveContent to strictly separate Google Maven artifacts from Maven Central, while adding specific repositories for GradleUp and Apollo previews. This change ensures consistent dependency versions across the project and simplifies the configuration for test projects via gradle/test.settings.gradle.kts.

gradle · high confidence

The Gradle wrapper configuration has been updated to use Gradle 9.4.0. This change ensures that builds are executed with the specified Gradle distribution, providing consistency across development environments and CI pipelines.

gradle/wrapper · high confidence

The \libraries/apollo-api/api\ location now contains the initial public API dumps (\apollo-api.api\ and \apollo-api.klib.api\) for the Apollo API module. This establishes the baseline public surface area for the core API types, including \Adapter\, \ApolloRequest\, \ApolloResponse\, \ExecutionContext\, and the JSON reader/writer interfaces, across JVM and Kotlin/Native targets.

libraries/apollo-api/api · high confidence

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

• CAI 70 → 71 (+0.2)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 88 → 88 (+0.0)
• Architecture 100 → 88 (-11.6)
• Maturity 75 → 75 (+0.1)
• Readiness 76 → 64 (-12.7)
• Security 61 → 70 (+9.5)
• Performance 100 (new)

• High CVE: [CVE redacted] (kotlin-js-store/package-lock.json)
• Hotspot: libraries/apollo-ast/src/commonMain/kotlin/com/apollographql/apollo/ast/internal/ExecutableValidationScope.kt (libraries/apollo-ast/src/commonMain/kotlin/com/apollographql/apollo/ast/internal/ExecutableValidationScope.kt)
• Hotspot: libraries/apollo-ast/src/commonMain/kotlin/com/apollographql/apollo/ast/internal/fields_merging.kt (libraries/apollo-ast/src/commonMain/kotlin/com/apollographql/apollo/ast/internal/fields_merging.kt)
• Hotspot: libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/ir/IrOperationsBuilder.kt (libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/ir/IrOperationsBuilder.kt)
• Hotspot: libraries/apollo-execution/src/commonMain/kotlin/com/apollographql/apollo/execution/internal/OperationContext.kt (libraries/apollo-execution/src/commonMain/kotlin/com/apollographql/apollo/execution/internal/OperationContext.kt)
• Medium CVE: [CVE redacted] (kotlin-js-store/package-lock.json)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2

• Consequences/trade-offs (e.g. higher context-switch cost for plumbing) and whether coroutines are actually used beyond the interceptor rationale are not visible before the clip (design-docs/Threading.md)
• Documentation: no installation or build instructions (benchmark/README.md)
• Documentation: no usage examples (benchmark/README.md)
• Hotspot: libraries/apollo-gradle-plugin/src/main/kotlin/com/apollographql/apollo/gradle/internal/DefaultApolloExtension.kt (libraries/apollo-gradle-plugin/src/main/kotlin/com/apollographql/apollo/gradle/internal/DefaultApolloExtension.kt)
• Low cohesion: DefaultApolloCompilerRegistry (LCOM4 8) (libraries/apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/internal/DefaultApolloCompilerRegistry.kt)
• Off the main sequence: multi-modules-custom-scalar:root
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #1
• Split libraries/apollo-api
• Split libraries/apollo-ast
• Split libraries/apollo-compiler
• Split libraries/apollo-runtime

• 8 commits — 6 feature/other, 2 fixes

• docs/source — 2 commits
• libraries/apollo-api — 2 commits
• libraries/apollo-ast — 1 commit
• libraries/apollo-compiler — 1 commit
• libraries/apollo-execution — 1 commit
• tests/kotlin-js-store — 1 commit

• fix: Fix @catch handling of malformed response data (#7027)
• fix: Fix JavaCodegen referencing inexistant symbols (#7031)
• change: Add exposeServiceCapabilities (#7026)
• change: Add guidance to the Garbage Collection doc (#7025)
• change: Bump version to 5.2.1 SNAPSHOT (#7030)
• change: Default to allowing empty selection sets (#7028)
• change: Version is now 5.2.0-SNAPSHOT (#7029)
• change: undeprecate CompiledFragment. (#7024)

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

• apollo-api
• apollo-ast
• apollo-compiler
• apollo-execution
• apollo-gradle-plugin
• apollo-normalized-cache
• apollo-normalized-cache-api
• apollo-runtime
• microbenchmark

• apollo-tooling

• apollo-compiler → apollo-ast
• apollo-execution → apollo-api (coupling)
• apollo-execution → apollo-ast
• apollo-normalized-cache → apollo-api
• apollo-normalized-cache → apollo-normalized-cache-api (coupling)
• apollo-normalized-cache → apollo-runtime
• apollo-normalized-cache-api → apollo-api
• apollo-runtime → apollo-api (coupling)

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

apollographql/apollo-kotlin 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.