Apollo Client

Apollo Client 4.2 introduces optional "classic" and "modern" method/hook signatures to improve type accuracy based on default options. This release also adds comprehensive support for automatic event-based query refetching via the new RefetchEventManager.

This minor release primarily involves a version bump to the release candidate (rc) version.

This patch fixes an issue with `refetchOn` merging logic when default and per-query options conflict, and introduces customization for the default event handler in `RefetchEventManager`.

This release enhances type safety for default options when using `preloadQuery` by extending the existing work from `defaultOptions` to the preloading mechanism.

This patch release addresses an issue where the deprecation warning for classic function signatures was incorrectly applied when using type inference with TypedDocumentNode.

This patch release improves developer experience by ensuring proper IntelliSense suggestions for the options object in several core query hooks.

This release introduces automatic event-based refetching capabilities through the new RefetchEventManager, allowing queries to automatically refresh on events like window focus or network reconnection. Event refetching is opt-in and highly configurable at both the client and query levels.

This release enhances type safety for mutations by propagating the `errorPolicy` setting from `defaultOptions` and individual calls into the return types of `client.mutate` and `useMutation`.

This patch release addresses a build artifact issue by removing the unnecessary "workspaces" field from the published package.json to silence Yarn v1 warnings.

This patch release introduces a new agent skill for integration with @tanstack/intent, bundled within the npm package.

Apollo Client 4.2 introduces 'classic' and 'modern' signature styles, enhancing type safety by synchronizing hook/method return types with declared default options. This requires explicit type declaration for used default options to maintain type accuracy.

This patch release addresses an interop issue related to RxJS when using WebSocketLink.

This patch release fixes issues related to deprecation warning silencing across entrypoints and within React hooks, and deprecates the `variableMatcher` option in `MockLink`.

This patch release includes changes from versions 4.1.5 and 4.1.6.

This patch release addresses a specific hydration mismatch issue occurring in `useQuery` when server-side rendering is disabled alongside query skipping.

This patch release addresses two specific bugs: one concerning unnecessary polling in useQuery when skipped, and another regarding incorrect option application in client.query.

This minor release improves the TypeScript return type accuracy for `client.query` based on the configured `errorPolicy`, specifically making the `data` property non-nullable when `errorPolicy` is set to 'none'.

This patch release ensures that PersistedQueryLink correctly merges context values for http and fetchOptions.

This patch introduces support for cancellation via `AbortController` in subscriptions created by `createFetchMultipartSubscription`.

This patch release addresses several issues related to Server-Side Rendering (SSR) behavior, specifically ensuring correct handling of fetch policies and skip tokens during initial data reading.

This patch release fixes an issue related to the resolution of @client fields nested under aliased server fields.

This release introduces significant enhancements to cache interaction, including support for array watching via fragments, new options for context in `useMutation`, and expanded support for GraphQL incremental delivery specifications like `@defer` (v17 alpha 9) and `@stream`.

This patch release ensures that internal utilities `compact` and `mergeOptions` correctly preserve symbol keys, resolving an issue with `defaultOptions` in `watchQuery`.

This patch release addresses a potential memory leak issue related to Trie nodes remaining in memory too long.

Added stream‑info handling improvements, exposed a new type for cache extensions, and fixed redundant merge calls, with a breaking change affecting the legacy `Defer20220824Handler`.

This patch release adds automatic cleanup of PreloadedQueryRef instances and changes @stream array truncation to occur only on the final chunk.

This release adds new cache behavior for undefined array items, introduces an \`extensions\` option to cache write methods, and improves fragment hooks with memoized observable mapping.

Patch release fixing refetch behavior for standby queries and replacing `findLast` with compatible methods, plus a hidden option for framework integrations.

Patch release addressing a memory leak in Apollo Client.

Added support for a `headers` transport, improving client awareness.

Introduces a new `from` option for readFragment, watchFragment, and updateFragment.

Performance improvement: `watchFragment` now reuses existing observables, reducing overhead during repeated cache watches.

Patch release fixing incremental chunk error handling in `ErrorLink` and improving `@stream` processing with `Defer20220824Handler` to prevent runtime errors.

The release upgrades all upstream dependencies to their next major versions, potentially introducing breaking changes.

This patch adds flexibility to FragmentType generics and introduces a new QueryRef.ForQuery helper type.

This release adds a callback‑based `context` option for `useMutation` and introduces a validation error for `@stream` without an `incrementalDelivery` handler.

This release adds null and array support to fragment watching APIs, introduces a `getCurrentResult` helper, deduplicates duplicate watches for better performance, and includes several bug fixes and incremental delivery updates.

This release introduces an abstract `resolvesClientField` API, adds experimental feature support, and refines `@client` field handling, including warnings for `no-cache` queries.

This release adds support for the newer incremental delivery format for `@defer` and introduces `@stream` handling across handlers, while fixing several bugs related to deferred payloads and fetchMore rendering.

Patch release fixes a regression in `useSuspenseQuery` and `useBackgroundQuery` where changing to `skipToken` unintentionally created a new ObservableQuery and caused refetches without variables.

Patch release fixing cache.modify() handling of readonly arrays.

Patch release removes the `operationType` field from `GraphQLWsLink` payloads, fixing related bugs but may require server adjustments.

Patch release fixing fetchMore loading state reset issue.

Patch release that fixes an invariance type error in the MockedResponse type.

This patch release adds a type‑safe `skipToken` for query skipping, fixes unhandled promise rejections and invariant handling, and switches to a named `equal` export from `@wry/equality`, which requires import updates.

Patch release that fixes a deep re-export issue in the React internals and enhances IntelliSense for `useMutation` variables.

The patch restores access to `getMemoryInternals` in development builds.

Patch release fixing the misplaced `networkStatus` implementation.

This patch fixes the CJS build for `invariantErrorCodes` and introduces the new utility `isNetworkStatusInFlight` while adding the deprecated `isNetworkStatusSettled` to Apollo Client utilities.

This patch adds and re-exports network status utilities, introducing `isNetworkStatusInFlight` and deprecating `isNetworkStatusSettled`.

This release adds a new GraphQL Codegen plugin for generating LocalState resolver types and bumps the codegen package version to a release candidate.

Apollo Client 4.0 introduces a framework‑agnostic core, unified error handling, opt‑in local state, a new `dataState` property, and class‑based links, while removing `ApolloError` and several legacy APIs, requiring code migrations.

Apollo Client 4.x introduces extensive migration tooling, renames import entry points, and overhauls client setup options, requiring developers to run codemods and adjust configuration.

This minor release adds extensive deprecation warnings for APIs removed in Apollo Client 4.0 and introduces `preloadQuery.toPromise` as the new way to await preloaded queries, along with a fix for field‑policy merging.

Apollo Client introduces a `clientSetup` codemod to restructure client configuration and a `legacyEntryPoints` transformation to update import paths, requiring updates to option names, removed settings, and import statements.

Introduces a versioning policy for Apollo Client.

Introduced a @apollo/client/v4-migration entrypoint that surfaces removed values and types with migration guidance, addressing breaking changes from their removal.

This minor release extends the `imports` codemod and adds new `links` and `removals` codemods.

This release introduces a breaking change requiring explicit type augmentation for incremental delivery handlers and removes the `DataMasking` interface, necessitating code updates.

This release makes data‑masking types opt‑in only, removes the `mode` option and the `Masked`/`MaskedDocumentNode` types, and requires migration steps to adjust type declarations.

This release adds production logging for invariant.error, extends HttpLink and BatchHttpLink context options with client awareness settings, and fixes AbortSignal handling.

This release removes exported helpers, tightens type definitions, moves link types into a namespace, and updates RetryLink behavior, introducing breaking changes that require code adjustments.

This release introduces several breaking TypeScript API changes—including read-only operation contexts, removal of certain request fields, and stricter link handler requirements—while adding features like multi-link concatenation and improved type safety.

Patch release fixing a race condition when queries are reobserved before their initial subscription.

The update removes the `DataProxy` namespace, flips generic type orders, disallows the `mutation` option in `useMutation`, deprecates old type exports, and removes `ApolloConsumer`, requiring code adjustments.

This release adds improved handling of masked fragments, introduces dataState in watchFragment, normalizes empty argument storage, and updates cache read behavior, while deprecating old readFragment/readQuery signatures and removing gql from the react entrypoint.

The `gql` export was removed from `@apollo/client/react`; import it from `@apollo/client` instead.

Introduces `dataState` and customizable `DataValue` types for `useFragment` and `useSuspenseFragment`.

Minor release that bumps the version to the latest release candidate.

Apollo Client now ships a React-Compiler compiled version of its React hooks via a new @apollo/client/react/compiled entry point, and the client.reFetchObservableQueries method has been renamed to client.refetchObservableQueries (deprecated alias retained).

This minor release adds @deprecated tags to removed query‑related properties and introduces a warning when `standby` fetch policy is used with `client.query`.

Apollo Client 4.0 introduces the new `preloadQuery.toPromise` API and removes the old `queryRef.toPromise`, while adding numerous deprecation warnings across React APIs, ApolloClient options, and cache settings. A bug fix prevents field policies from incorrectly merging into supertype policies.

Apollo Client 4.x introduces a migration codemod to update old 3.x import paths to the new 4.x entrypoints.

This release introduces a breaking change to `SetContextLink` callback parameters and operation type, adds overridable `DataValue` types for response states, and includes bug fixes for `operationType` propagation and `subscribeToMore` error typing.

This release removes two deprecated configuration options, adds a new `operationType` field for easier operation checks, exports several types, and includes bug fixes around resolver warnings and query rerendering.

Version bump for codegen to release as a release candidate (rc).

This release only bumps the version to publish the latest code as a release candidate.

This release introduces significant improvements to `cache-only` query behavior, making them more predictable by preventing unnecessary fetches and initial loading states. It also modernizes link creation by favoring classes over creator functions and refines option inheritance in `fetchMore`.

This release introduces enhanced client awareness, changes default behaviors for extensions and multipart Accept headers, adds new link utilities, and enforces stricter alias rules, along with a bug fix for persisted queries.

Added streaming support for `@defer` queries with a new `NetworkStatus.streaming` value and changed loading semantics, removed the `context` option from `useLazyQuery`, and made `cache.fragmentMatches` mandatory.

Apollo Client 8 introduces breaking API changes: ObservableQuery loses its queryId, getObservableQueries now returns a Set, and preloadQuery’s toPromise API changes, while adding a new ObservableQuery.stop method and more aggressive client cleanup.

Adds subscription restart capability and full‑lifecycle deduplication, while changing early‑unsubscribe behavior for ObservableQuery.

Introduces an optional override mechanism for Apollo Client’s DataMasking types, allowing custom implementations while preserving default behavior.

This release introduces a new `dataState` property and modifies the `TData` generic handling, removes the deprecated `QueryReference` type, and adds a `.retain()` method to result promises, requiring migration of type signatures and handling of lazy query execution.

This release aligns Apollo Client with the GraphQL over HTTP spec by adding `application/graphql-response+json` support, changing error handling, and updating the default `Accept` header, while introducing breaking changes to `ServerError` and link notifications.

A new GraphQL Codegen plugin '@apollo/client-graphql-codegen/local-state' adds generated resolver types for LocalState, enabling type‑safe local resolvers.

This release moves unstable testing utilities to an internal namespace, removes several deprecated testing helpers, adds subtle `useQuery` and `ObservableQuery` behavior improvements, and deprecates old MockLink type exports.

Apollo Client introduces a new `LocalState` system, removes several legacy APIs, and changes resolver context handling, requiring migration steps for existing applications.

Apollo Client introduces a restructuring of utility modules and removal of experimental testing utilities, requiring import path updates and migration to the GraphQL Testing Library.

Apollo Client 4.x introduces breaking changes: removal of `typeDefs`, `TContext`, and support for `graphql` v15, a mandatory `link` option, and a renamed link entrypoint, requiring migration steps for existing code.

Apollo Client vX introduces major API changes: context no longer provides `cache`/`forceFetch`, `ApolloLink.execute` now requires a client argument, and `useMutation` typings are stricter, alongside new features like custom context typing and a re‑exported `gql`.

This release introduces stricter variable handling, new error utilities, and several breaking changes such as removal of `standby` fetchPolicy and deprecation of `never` as a TVariables type.

Patch release fixing an issue where in‑flight multipart urql subscriptions could be incorrectly cancelled.

This release introduces automatic loading state emission by default and adds initial loading support for ObservableQuery, while fixing several useLazyQuery and polling behaviors.

This release adds a unified error handling API for `onError`, enhances `MockLink` with variable callbacks, realistic delay helpers, and default delay configuration, while removing deprecated methods and options that require migration.

This patch refactors notification scheduling and cache emit logic by moving code from QueryInfo to ObservableQuery, with no functional changes.

Patch release fixes ObservableQuery behavior in useQuery, keeping it inactive until the first subscription.

Removed several React entry points and the parser cache, requiring import updates to `@apollo/client/react` and removal of parser usage.

This release introduces stricter error handling for empty link chains, removes obsolete loading‑state properties from promise‑based query APIs, adds partial data to combined GraphQL errors, and provides a new `prerenderStatic` SSR method while deprecating older SSR helpers.