Apollo Client

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.

The update replaces `FetchResult` with new `SubscribeResult` and `MutateResult` types, removes deprecated subscription callbacks, unifies error handling, and includes several bug fixes and SSR improvements.

Apollo Client v4 introduces public `reobserve`, renames network fetch control to `prioritizeCacheValues`, removes several legacy hook types, and restructures React hook typings, requiring migration steps.

Network errors now respect `errorPolicy` and the `called` property was removed from `useQuery`, requiring updates to error handling and query state checks.

Patch release resolves a cache-first query bug that caused stale data to be returned under certain variable and skip conditions.

Apollo Client 4.0 removes several generic arguments and options, defaults data and variable types to `unknown`/`OperationVariables`, and fixes the CommonJS build, requiring code updates for TypeScript users.

Apollo Client removes legacy streaming workarounds and several polyfills, adds a react-server entry point, and drops the rehackt dependency, resulting in a smaller bundle but requiring updated fetch implementations and React Native versions.

Apollo Client introduces major breaking changes by removing several legacy utilities, dropping React 16 support, and replacing the `ApolloError` wrapper with new error classes, while adding `CombinedGraphQLErrors`, `CombinedProtocolErrors`, and updated query behaviors.

Patch release resolves import problems with external CJS modules by switching to a star import from `rehackt`.

Patch release corrects networkStatus reporting for queries with errorPolicy "all", fixing observableQuery, useQuery, and useLazyQuery behavior.

Patch release fixing symbol duplication, DeepOmit typing, and MockLink debug output.

Patch release introduces a breaking change to ObservableQuery.refetch behavior and adds a new exported type UseSuspenseFragmentOptions.

Apollo Client 3.13.0 adds the `useSuspenseFragment` hook, improves TypeScript typings, and fixes several bugs, while deprecating several callbacks and options.

This release introduces the useSuspenseFragment hook, improves type safety for updateQuery, adds multipart query deduplication, deprecates several callbacks and options, and includes several bug fixes and type corrections.

Patch release fixing observableQuery status handling for fetchMore with no-cache policy and adding the missing main.d.cts file.

Patch release fixing a React 19 hook order warning and adding `graphql-ws` ^6.0.3 as a supported peer dependency.

Patch release fixes the `extensions` type in `ApolloError` and adds retry support for multipart subscription transport errors via `RetryLink`.

Patch release fixing a crash in watchFragment/useFragment with @includes and removing the unused response-iterator dependency.

Patch release adds a `protocolErrors` property to surface fatal transport‑level errors in multipart subscriptions and fixes the `errors` field type on `ApolloPayloadResult`.

Patch release fixing type preservation and scalar handling for `Unmasked` usage.