@apollo/client

Minor Changes

• Support headers transport for enhanced client awareness.

• You can now provide a callback function as the context option on the mutate function returned by useMutation. The callback function is called with the value of the context option provided to the useMutation hook. This is useful if you'd like to merge the context object provided to the useMutation hook with a value provided to the mutate function.

  function MyComponent() {
    const [mutate, result] = useMutation(MUTATION, {
      context: { foo: true },
    });
  
    async function runMutation() {
      await mutate({
        // sends context as { foo: true, bar: true }
        context: (hookContext) => ({ ...hookContext, bar: true }),
      });
    }
  
    // ...
  }

• Fix an issue where deferred payloads that returned arrays with fewer items than the original cached array would retain items from the cached array. This change includes @stream arrays where stream arrays replace the cached arrays.

• Don't set the fallback value of a @client field to null when a read function is defined. Instead the read function will be called with an existing value of undefined to allow default arguments to be used to set the returned value.

  When a read function is not defined nor is there a defined resolver for the field, warn and set the value to null only in that instance.

• Add support for from: null in client.watchFragment and cache.watchFragment. When from is null, the emitted result is:

  {
    data: null,
    dataState: "complete",
    complete: true,
  }

• Support the newer incremental delivery format for the @defer directive implemented in graphql@17.0.0-alpha.9. Import the GraphQL17Alpha9Handler to use the newer incremental delivery format with @defer.

  import { GraphQL17Alpha9Handler } from "@apollo/client/incremental";
  
  const client = new ApolloClient({
    // ...
    incrementalHandler: new GraphQL17Alpha9Handler(),
  });

  Note

  In order to use the GraphQL17Alpha9Handler, the GraphQL server MUST implement the newer incremental delivery format. You may see errors or unusual behavior if you use the wrong handler. If you are using Apollo Router, continue to use the Defer20220824Handler because Apollo Router does not yet support the newer incremental delivery format.

• Add support for arrays with useFragment, useSuspenseFragment, and client.watchFragment. This allows the ability to use a fragment to watch multiple entities in the cache. Passing an array to from will return data as an array where each array index corresponds to the index in the from array.

  function MyComponent() {
    const result = useFragment({
      fragment,
      from: [item1, item2, item3],
    });
  
    // `data` is an array with 3 items
    console.log(result); // { data: [{...}, {...}, {...}], dataState: "complete", complete: true }
  }

• Add a getCurrentResult function to the observable returned by client.watchFragment and cache.watchFragment that returns the current value for the watched fragment.

  const observable = client.watchFragment({
    fragment,
    from: { __typename: "Item", id: 1 },
  });
  
  console.log(observable.getCurrentResult());
  // {
  //   data: {...},
  //   dataState: "complete",
  //   complete: true,
  // }

• Add the from option to readFragment, watchFragment, and updateFragment.

• Add support for the @stream directive on both the Defer20220824Handler and the GraphQL17Alpha2Handler.

  Note

  The implementations of @stream differ in the delivery of incremental results between the different GraphQL spec versions. If you upgrading from the older format to the newer format, expect the timing of some incremental results to change.

• InMemoryCache no longer filters out explicitly returned undefined items from read functions for array fields. This now makes it possible to create read functions on array fields that return partial data and trigger a fetch for the full list.

• Add an extensions option to cache.write, cache.writeQuery, and client.writeQuery. This makes extensions available in cache merge functions which can be accessed with the other merge function options.

  As a result of this change, any extensions returned in GraphQL operations are now available in merge in the cache writes for these operations.

• Add an abstract resolvesClientField function to ApolloCache that can be used by caches to tell LocalState if it can resolve a @client field when a local resolver is not defined.

  LocalState will emit a warning and set a fallback value of null when no local resolver is defined and resolvesClientField returns false, or isn't defined. Returning true from resolvesClientField signals that a mechanism in the cache will set the field value. In this case, LocalState won't set the field value.

• Use the default stream merge function for @stream fields only if stream info is present. This change means that using the older Defer20220824Handler will not use the default stream merge function and will instead truncate the streamed array on the first chunk.

Patch Changes

• Ensure that PreloadedQueryRef instances are unsubscribed when garbage collected

• Change the returned value from null to {} when all fields in a query were skipped.

  This also fixes a bug where useSuspenseQuery would suspend indefinitely when all fields were skipped.

• Fix an issue where errors parsed from incremental chunks in ErrorLink might throw when using the GraphQL17Alpha9Handler.

• Deduplicate watches created by useFragment, client.watchFragment, and cache.watchFragment that contain the same fragment, variables, and identifier. This should improve performance in situations where a useFragment or a client.watchFragment is used to watch the same object in multiple places of an application.

• Allow FragmentType not only to be called as FragmentType<TData>, but also as FragmentType<TypedDocumentNode>.

• Fix an issue where calling fetchMore with @defer or @stream would not rerender incremental results as they were streamed.

• Truncate @stream arrays only on last chunk by default.

• Expose the ExtensionsWithStreamInfo type for extensions in Cache.writeQuery, Cache.write and Cache.update so other cache implementations also can correctly access them.

• Improve the cache data loss warning message when existing or incoming is an array.

• Ignore top-level data values on subsequent chunks in incremental responses.

• Create mechanism to add experimental features to Apollo Client

• Ensure LocalState doesn't try to read from the cache when using a no-cache fetch policy.

• Ensure an error is thrown when @stream is detected and an incrementalDelivery handler is not configured.

• Use memoized observable mapping when using watchFragment, useFragment or useSuspenseFragment.

• Add helper type QueryRef.ForQuery<TypedDocumentNode>

• Pass streamInfo through result extensions as a WeakRef.

• Fix the Defer20220824Handler.SubsequentResult type to match the FormattedSubsequentIncrementalExecutionResult type in graphql@17.0.0-alpha.2.

• Warn when using a no-cache fetch policy without a local resolver defined. no-cache queries do not read or write to the cache which meant no-cache queries are silently incomplete when the @client field value was handled by a cache read function.

• Update the accept header used with the GraphQL17Alpha9Handler to multipart/mixed;incrementalSpec=v0.2 to ensure the newest incremental delivery format is requested.

• DeepPartial<Array<TData>> now returns Array<DeepPartial<TData>> instead of Array<DeepPartial<TData | undefined>>.

• prerenderStatic: Expose return value of renderFunction to userland, fix aborted property.

  This enables usage of resumeAndPrerender with React 19.2.

• Reduce the number of observables created by watchFragment by reusing existing observables as much as possible. This should improve performance when watching the same item in the cache multiple times after a cache update occurs.

• Handle @stream payloads that send multiple items in the same chunk when using the Defer20220824Handler.

• Handle an edge case with the Defer20220824Handler where an error for a @stream item that bubbles to the @stream boundary (such as an item returning null for a non-null array item) would write items from future chunks to the wrong array index. In these cases, the @stream field is no longer processed and future updates to the field are ignored. This prevents runtime errors that TypeScript would otherwise not be able to catch.

• Avoid calling merge functions more than once for the same incremental chunk.