@apollo/client 4.0.10 → 4.0.12-beta.0

package/__cjs/utilities/internal/ponyfills/index.react-native.d.cts

@@ -0,0 +1,2 @@
+export { FinalizationRegistry } from "./FinalizationRegistry.cjs";
+//# sourceMappingURL=index.react-native.d.cts.map

package/__cjs/utilities/internal/types/ExtensionsWithStreamDetails.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ExtensionsWithStreamDetails.cjs.map

package/__cjs/utilities/internal/types/ExtensionsWithStreamDetails.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionsWithStreamDetails.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/__cjs/utilities/internal/types/ExtensionsWithStreamDetails.d.cts

@@ -0,0 +1,24 @@
+import type { Trie } from "@wry/trie";
+import type { Incremental } from "@apollo/client/incremental";
+import type { streamDetailsSymbol } from "../constants.cjs";
+/**
+* @internal
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+export interface ExtensionsWithStreamDetails extends Record<string, unknown> {
+    [streamDetailsSymbol]?: {
+        current: Trie<{
+            current: Incremental.StreamFieldInfo;
+        }>;
+    };
+}
+/**
+* @internal
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+export interface WithExtensionsWithStreamDetails {
+    extensions?: ExtensionsWithStreamDetails;
+}
+//# sourceMappingURL=ExtensionsWithStreamDetails.d.cts.map

package/__cjs/version.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = exports.version = void 0;
-exports.version = "4.0.10";
+exports.version = "4.0.12-beta.0";
 exports.build = "cjs";
 //# sourceMappingURL=version.cjs.map

package/__cjs/version.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"version.cjs","sources":["../../src/version.ts"],"sourcesContent":["export const version = \"local\" as string;\nexport const build = \"source\" as \"source\" | \"esm\" | \"cjs\";\n"],"names":[],"mappings":";;;AAAa,CAAb,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAa,CAAb,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,UAAwC;AAC3B,CAAb,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAa,CAAb,CAAA,CAAA,CAAA,EAAA,OAAyD;"}
+{"version":3,"file":"version.cjs","sources":["../../src/version.ts"],"sourcesContent":["export const version = \"local\" as string;\nexport const build = \"source\" as \"source\" | \"esm\" | \"cjs\";\n"],"names":[],"mappings":";;;AAAa,CAAb,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAa,CAAb,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,iBAAwC;AAC3B,CAAb,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAa,CAAb,CAAA,CAAA,CAAA,EAAA,OAAyD;"}

package/cache/core/cache.d.ts

@@ -1,14 +1,18 @@
 import type { DocumentNode, FragmentDefinitionNode, InlineFragmentNode } from "graphql";
 import { Observable } from "rxjs";
-import type { GetDataState, OperationVariables, TypedDocumentNode } from "@apollo/client";
+import type { DataValue, GetDataState, OperationVariables, TypedDocumentNode } from "@apollo/client";
 import type { FragmentType, Unmasked } from "@apollo/client/masking";
 import type { Reference, StoreObject } from "@apollo/client/utilities";
-import type { NoInfer } from "@apollo/client/utilities/internal";
+import type { IsAny, NoInfer, Prettify } from "@apollo/client/utilities/internal";
 import { getApolloCacheMemoryInternals } from "@apollo/client/utilities/internal";
 import type { Cache } from "./types/Cache.js";
 import type { MissingTree } from "./types/common.js";
 export type Transaction = (c: ApolloCache) => void;
 export declare namespace ApolloCache {
+    /**
+     * Acceptable values provided to the `from` option.
+     */
+    type FromOptionValue<TData> = StoreObject | Reference | FragmentType<NoInfer<TData>> | string;
     /**
      * Watched fragment options.
      */
@@ -28,7 +32,7 @@ export declare namespace ApolloCache {
          *
          * @docGroup 1. Required options
          */
-        from: StoreObject | Reference | FragmentType<NoInfer<TData>> | string;
+        from: ApolloCache.FromOptionValue<TData> | Array<ApolloCache.FromOptionValue<TData> | null> | null;
         /**
          * Any variables that the GraphQL fragment may depend on.
          *
@@ -56,13 +60,51 @@ export declare namespace ApolloCache {
     /**
      * Watched fragment results.
      */
-    type WatchFragmentResult<TData = unknown> = ({
+    type WatchFragmentResult<TData = unknown> = true extends IsAny<TData> ? ({
+        complete: true;
+        missing?: never;
+    } & GetDataState<any, "complete">) | ({
+        complete: false;
+        missing?: MissingTree;
+    } & GetDataState<any, "partial">) : TData extends null | null[] ? Prettify<{
+        complete: true;
+        missing?: never;
+    } & GetDataState<TData, "complete">> : Prettify<{
         complete: true;
         missing?: never;
-    } & GetDataState<TData, "complete">) | ({
+    } & GetDataState<TData, "complete">> | {
         complete: false;
-        missing: MissingTree;
-    } & GetDataState<TData, "partial">);
+        missing?: MissingTree;
+        /**
+        * An object containing the result of your GraphQL query after it completes.
+        * 
+        * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+        * 
+        * @docGroup 1. Operation data
+        */
+        data: TData extends Array<infer TItem> ? Array<DataValue.Partial<TItem> | null> : DataValue.Partial<TData>;
+        /**
+        * Describes the completeness of `data`.
+        * 
+        * - `empty`: No data could be fulfilled from the cache or the result is
+        *   incomplete. `data` is `undefined`.
+        * - `partial`: Some data could be fulfilled from the cache but `data` is
+        *   incomplete. This is only possible when `returnPartialData` is `true`.
+        * - `streaming`: `data` is incomplete as a result of a deferred query and
+        *   the result is still streaming in.
+        * - `complete`: `data` is a fully satisfied query result fulfilled
+        *   either from the cache or network.
+        * 
+        * @docGroup 1. Operation data
+        */
+        dataState: "partial";
+    };
+    interface ObservableFragment<TData = unknown> extends Observable<ApolloCache.WatchFragmentResult<TData>> {
+        /**
+         * Return the current result for the fragment.
+         */
+        getCurrentResult: () => ApolloCache.WatchFragmentResult<TData>;
+    }
 }
 export declare abstract class ApolloCache {
     readonly assumeImmutableResults: boolean;
@@ -98,6 +140,72 @@ export declare abstract class ApolloCache {
     abstract removeOptimistic(id: string): void;
     abstract fragmentMatches(fragment: InlineFragmentNode | FragmentDefinitionNode, typename: string): boolean;
     lookupFragment(fragmentName: string): FragmentDefinitionNode | null;
+    /**
+     * Determines whether a `@client` field can be resolved by the cache. Used
+     * when `LocalState` does not have a local resolver that can resolve the
+     * field.
+     *
+     * @remarks Cache implementations should return `true` if a mechanism in the
+     * cache is expected to provide a value for the field. `LocalState` will set
+     * the value of the field to `undefined` in order for the cache to handle it.
+     *
+     * Cache implementations should return `false` to indicate that it cannot
+     * handle resolving the field (either because it doesn't have a mechanism to
+     * do so, or because the user hasn't provided enough information to resolve
+     * the field). Returning `false` will emit a warning and set the value of the
+     * field to `null`.
+     *
+     * A cache that doesn't implement `resolvesClientField` will be treated the
+     * same as returning `false`.
+     */
+    resolvesClientField?(typename: string, fieldName: string): boolean;
+    /**
+     * Executes multiple cache operations as a single batch, ensuring that
+     * watchers are only notified once after all operations complete. This is
+     * useful for improving performance when making multiple cache updates, as it
+     * prevents unnecessary re-renders or query refetches between individual
+     * operations.
+     *
+     * The `batch` method supports both optimistic and non-optimistic updates, and
+     * provides fine-grained control over which cache layer receives the updates
+     * and when watchers are notified.
+     *
+     * For usage instructions, see [Interacting with cached data: `cache.batch`](https://www.apollographql.com/docs/react/caching/cache-interaction#using-cachebatch).
+     *
+     * @example
+     *
+     * ```js
+     * cache.batch({
+     *   update(cache) {
+     *     cache.writeQuery({
+     *       query: GET_TODOS,
+     *       data: { todos: updatedTodos },
+     *     });
+     *     cache.evict({ id: "Todo:123" });
+     *   },
+     * });
+     * ```
+     *
+     * @example
+     *
+     * ```js
+     * // Optimistic update with a custom layer ID
+     * cache.batch({
+     *   optimistic: "add-todo-optimistic",
+     *   update(cache) {
+     *     cache.modify({
+     *       fields: {
+     *         todos(existing = []) {
+     *           return [...existing, newTodoRef];
+     *         },
+     *       },
+     *     });
+     *   },
+     * });
+     * ```
+     *
+     * @returns The return value of the `update` function.
+     */
     batch<U>(options: Cache.BatchOptions<this, U>): U;
     abstract performTransaction(transaction: Transaction, optimisticId?: string | null): void;
     recordOptimisticTransaction(transaction: Transaction, optimisticId: string): void;
@@ -119,28 +227,35 @@ export declare abstract class ApolloCache {
      * instead of passing it as a separate option.
      */
     optimistic: boolean): Unmasked<TData> | null;
+    private fragmentWatches;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
+        from: Array<ApolloCache.FromOptionValue<TData>>;
+    }): ApolloCache.ObservableFragment<Array<Unmasked<TData>>>;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
+        from: Array<null>;
+    }): ApolloCache.ObservableFragment<Array<null>>;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
+        from: Array<ApolloCache.FromOptionValue<TData> | null>;
+    }): ApolloCache.ObservableFragment<Array<Unmasked<TData> | null>>;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
+        from: null;
+    }): ApolloCache.ObservableFragment<null>;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables> & {
+        from: ApolloCache.FromOptionValue<TData>;
+    }): ApolloCache.ObservableFragment<Unmasked<TData>>;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables>): ApolloCache.ObservableFragment<Unmasked<TData> | null>;
     /**
-    * Watches the cache store of the fragment according to the options specified
-    * and returns an `Observable`. We can subscribe to this
-    * `Observable` and receive updated results through an
-    * observer when the cache store changes.
-    * 
-    * You must pass in a GraphQL document with a single fragment or a document
-    * with multiple fragments that represent what you are reading. If you pass
-    * in a document with multiple fragments then you must also specify a
-    * `fragmentName`.
-    * 
-    * @since 3.10.0
-    * @param options - An object of type `WatchFragmentOptions` that allows
-    * the cache to identify the fragment and optionally specify whether to react
-    * to optimistic updates.
-    */
-    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloCache.WatchFragmentOptions<TData, TVariables>): Observable<ApolloCache.WatchFragmentResult<Unmasked<TData>>>;
+     * Can be overridden by subclasses to delay calling the provided callback
+     * until after all broadcasts have been completed - e.g. in a cache scenario
+     * where many watchers are notified in parallel.
+     */
+    protected onAfterBroadcast: (cb: () => void) => void;
+    private watchSingleFragment;
     private getFragmentDoc;
     /**
      * Read data from the cache for the specified fragment.
      */
-    readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ fragment, variables, fragmentName, id, optimistic, returnPartialData, }: Cache.ReadFragmentOptions<TData, TVariables>): Unmasked<TData> | null;
+    readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ fragment, variables, fragmentName, id, from, optimistic, returnPartialData, }: Cache.ReadFragmentOptions<TData, TVariables>): Unmasked<TData> | null;
     readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache.ReadFragmentOptions<TData, TVariables>, 
     /**
      * @deprecated Pass the `optimistic` argument as part of the first argument
@@ -158,9 +273,10 @@ export declare abstract class ApolloCache {
      * fragment to validate that the shape of the data you’re writing to the cache
      * is the same as the shape of the data required by the fragment.
      */
-    writeFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ data, fragment, fragmentName, variables, overwrite, id, broadcast, }: Cache.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    writeFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>({ data, fragment, fragmentName, variables, overwrite, id, from, broadcast, }: Cache.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
     updateQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache.UpdateQueryOptions<TData, TVariables>, update: (data: Unmasked<TData> | null) => Unmasked<TData> | null | void): Unmasked<TData> | null;
     updateFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache.UpdateFragmentOptions<TData, TVariables>, update: (data: Unmasked<TData> | null) => Unmasked<TData> | null | void): Unmasked<TData> | null;
+    private toCacheId;
     /**
     * @experimental
     * @internal

package/cache/core/cache.js

@@ -1,9 +1,11 @@
 import { WeakCache } from "@wry/caches";
+import { equal } from "@wry/equality";
+import { Trie } from "@wry/trie";
 import { wrap } from "optimism";
-import { Observable } from "rxjs";
-import { cacheSizes } from "@apollo/client/utilities";
+import { distinctUntilChanged, map, Observable, ReplaySubject, share, shareReplay, tap, timer, } from "rxjs";
+import { cacheSizes, canonicalStringify } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { equalByQuery, getApolloCacheMemoryInternals, getFragmentDefinition, getFragmentQueryDocument, } from "@apollo/client/utilities/internal";
+import { combineLatestBatched, equalByQuery, getApolloCacheMemoryInternals, getFragmentDefinition, getFragmentQueryDocument, mapObservableFragmentMemoized, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 export class ApolloCache {
     assumeImmutableResults = false;
@@ -14,11 +16,53 @@ export class ApolloCache {
         return null;
     }
     // Transactional API
-    // The batch method is intended to replace/subsume both performTransaction
-    // and recordOptimisticTransaction, but performTransaction came first, so we
-    // provide a default batch implementation that's just another way of calling
-    // performTransaction. Subclasses of ApolloCache (such as InMemoryCache) can
-    // override the batch method to do more interesting things with its options.
+    /**
+     * Executes multiple cache operations as a single batch, ensuring that
+     * watchers are only notified once after all operations complete. This is
+     * useful for improving performance when making multiple cache updates, as it
+     * prevents unnecessary re-renders or query refetches between individual
+     * operations.
+     *
+     * The `batch` method supports both optimistic and non-optimistic updates, and
+     * provides fine-grained control over which cache layer receives the updates
+     * and when watchers are notified.
+     *
+     * For usage instructions, see [Interacting with cached data: `cache.batch`](https://www.apollographql.com/docs/react/caching/cache-interaction#using-cachebatch).
+     *
+     * @example
+     *
+     * ```js
+     * cache.batch({
+     *   update(cache) {
+     *     cache.writeQuery({
+     *       query: GET_TODOS,
+     *       data: { todos: updatedTodos },
+     *     });
+     *     cache.evict({ id: "Todo:123" });
+     *   },
+     * });
+     * ```
+     *
+     * @example
+     *
+     * ```js
+     * // Optimistic update with a custom layer ID
+     * cache.batch({
+     *   optimistic: "add-todo-optimistic",
+     *   update(cache) {
+     *     cache.modify({
+     *       fields: {
+     *         todos(existing = []) {
+     *           return [...existing, newTodoRef];
+     *         },
+     *       },
+     *     });
+     *   },
+     * });
+     * ```
+     *
+     * @returns The return value of the `update` function.
+     */
     batch(options) {
         const optimisticId = typeof options.optimistic === "string" ? options.optimistic
             : options.optimistic === false ? null
@@ -57,6 +101,7 @@ export class ApolloCache {
             optimistic,
         });
     }
+    fragmentWatches = new Trie(true);
     /**
     * Watches the cache store of the fragment according to the options specified
     * and returns an `Observable`. We can subscribe to this
@@ -74,61 +119,159 @@ export class ApolloCache {
     * to optimistic updates.
     */
     watchFragment(options) {
-        const { fragment, fragmentName, from, optimistic = true, ...otherOptions } = options;
+        const { fragment, fragmentName, from } = options;
         const query = this.getFragmentDoc(fragment, fragmentName);
-        // While our TypeScript types do not allow for `undefined` as a valid
-        // `from`, its possible `useFragment` gives us an `undefined` since it
-        // calls` cache.identify` and provides that value to `from`. We are
-        // adding this fix here however to ensure those using plain JavaScript
-        // and using `cache.identify` themselves will avoid seeing the obscure
-        // warning.
-        const id = typeof from === "undefined" || typeof from === "string" ?
-            from
-            : this.identify(from);
-        if (__DEV__) {
-            const actualFragmentName = fragmentName || getFragmentDefinition(fragment).name.value;
-            if (!id) {
-                __DEV__ && invariant.warn(109, actualFragmentName);
+        const fromArray = Array.isArray(from) ? from : [from];
+        const ids = fromArray.map((value) => {
+            // While our TypeScript types do not allow for `undefined` as a valid
+            // `from`, its possible `useFragment` gives us an `undefined` since it
+            // calls` cache.identify` and provides that value to `from`. We are
+            // adding this fix here however to ensure those using plain JavaScript
+            // and using `cache.identify` themselves will avoid seeing the obscure
+            // warning.
+            const id = value == null ? value : this.toCacheId(value);
+            if (__DEV__) {
+                const actualFragmentName = fragmentName || getFragmentDefinition(fragment).name.value;
+                if (id === undefined) {
+                    __DEV__ && invariant.warn(113, actualFragmentName);
+                }
             }
+            return id;
+        });
+        if (!Array.isArray(from)) {
+            const observable = this.watchSingleFragment(ids[0], query, options);
+            // Unfortunately we forgot to allow for `null` on watchFragment in 4.0
+            // when `from` is a single record. As such, we need to fallback to {}
+            // when diff.result is null to maintain backwards compatibility. We
+            // should plan to change this in v5. We do however support `null` if
+            // `from` is explicitly `null`.
+            //
+            // NOTE: Using `from` with an array will maintain `null` properly
+            // without the need for a similar fallback since watchFragment with
+            // arrays is new functionality in v4.1.
+            return from === null ? observable : (mapObservableFragmentMemoized(observable, Symbol.for("apollo.transform.individualResult"), (result) => ({
+                ...result,
+                data: result.data ?? {},
+            })));
         }
-        const diffOptions = {
-            ...otherOptions,
-            returnPartialData: true,
-            id,
-            query,
-            optimistic,
-        };
-        let latestDiff;
-        return new Observable((observer) => {
-            return this.watch({
-                ...diffOptions,
-                immediate: true,
-                callback: (diff) => {
-                    let data = diff.result;
-                    // TODO: Remove this once `watchFragment` supports `null` as valid
-                    // value emitted
-                    if (data === null) {
-                        data = {};
-                    }
-                    if (
-                    // Always ensure we deliver the first result
-                    latestDiff &&
-                        equalByQuery(query, { data: latestDiff.result }, { data }, options.variables)) {
-                        return;
-                    }
-                    const result = {
+        let currentResult;
+        function toResult(results) {
+            const result = results.reduce((memo, result, idx) => {
+                memo.data.push(result.data);
+                memo.complete &&= result.complete;
+                memo.dataState = memo.complete ? "complete" : "partial";
+                if (result.missing) {
+                    memo.missing ||= {};
+                    memo.missing[idx] = result.missing;
+                }
+                return memo;
+            }, {
+                data: [],
+                dataState: "complete",
+                complete: true,
+            });
+            if (!equal(currentResult, result)) {
+                currentResult = result;
+            }
+            return currentResult;
+        }
+        if (ids.length === 0) {
+            return emptyArrayObservable;
+        }
+        let subscribed = false;
+        const observables = ids.map((id) => this.watchSingleFragment(id, query, options));
+        const observable = combineLatestBatched(observables).pipe(map(toResult), tap({
+            subscribe: () => (subscribed = true),
+            unsubscribe: () => (subscribed = false),
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+        return Object.assign(observable, {
+            getCurrentResult: () => {
+                if (subscribed && currentResult) {
+                    return currentResult;
+                }
+                const results = observables.map((observable) => observable.getCurrentResult());
+                return toResult(results);
+            },
+        });
+    }
+    /**
+     * Can be overridden by subclasses to delay calling the provided callback
+     * until after all broadcasts have been completed - e.g. in a cache scenario
+     * where many watchers are notified in parallel.
+     */
+    onAfterBroadcast = (cb) => cb();
+    watchSingleFragment(id, fragmentQuery, options) {
+        if (id === null) {
+            return nullObservable;
+        }
+        const { optimistic = true, variables } = options;
+        const cacheKey = [
+            fragmentQuery,
+            canonicalStringify({ id, optimistic, variables }),
+        ];
+        const cacheEntry = this.fragmentWatches.lookupArray(cacheKey);
+        if (!cacheEntry.observable) {
+            let subscribed = false;
+            let currentResult;
+            function getNewestResult(diff) {
+                const data = diff.result;
+                if (!currentResult ||
+                    !equalByQuery(fragmentQuery, { data: currentResult.data }, { data }, options.variables)) {
+                    currentResult = {
                         data,
                         dataState: diff.complete ? "complete" : "partial",
-                        complete: !!diff.complete,
+                        complete: diff.complete,
                     };
                     if (diff.missing) {
-                        result.missing = diff.missing.missing;
+                        currentResult.missing = diff.missing.missing;
                     }
-                    latestDiff = { ...diff, result: data };
-                    observer.next(result);
+                }
+                return currentResult;
+            }
+            const observable = new Observable((observer) => {
+                subscribed = true;
+                const cleanup = this.watch({
+                    variables,
+                    returnPartialData: true,
+                    id,
+                    query: fragmentQuery,
+                    optimistic,
+                    immediate: true,
+                    callback: (diff) => {
+                        observable.dirty = true;
+                        this.onAfterBroadcast(() => {
+                            observer.next(getNewestResult(diff));
+                            observable.dirty = false;
+                        });
+                    },
+                });
+                return () => {
+                    subscribed = false;
+                    cleanup();
+                    this.fragmentWatches.removeArray(cacheKey);
+                };
+            }).pipe(distinctUntilChanged(), share({
+                connector: () => new ReplaySubject(1),
+                // debounce so a synchronous unsubscribe+resubscribe doesn't tear down the watch and create a new one
+                resetOnRefCountZero: () => timer(0),
+            }));
+            cacheEntry.observable = Object.assign(observable, {
+                dirty: false,
+                getCurrentResult: () => {
+                    if (subscribed && currentResult) {
+                        return currentResult;
+                    }
+                    return getNewestResult(this.diff({
+                        id,
+                        query: fragmentQuery,
+                        returnPartialData: true,
+                        optimistic,
+                        variables,
+                    }));
                 },
             });
-        });
+        }
+        return cacheEntry.observable;
     }
     // Make sure we compute the same (===) fragment query document every
     // time we receive the same fragment in readFragment.
@@ -138,10 +281,11 @@ export class ApolloCache {
         cache: WeakCache,
     });
     readFragment(options, optimistic = !!options.optimistic) {
+        const id = options.from !== undefined ? this.toCacheId(options.from) : options.id;
         return this.read({
             ...options,
             query: this.getFragmentDoc(options.fragment, options.fragmentName),
-            rootId: options.id,
+            rootId: id,
             optimistic,
         });
     }
@@ -151,7 +295,8 @@ export class ApolloCache {
             result: data,
         }));
     }
-    writeFragment({ id, data, fragment, fragmentName, ...options }) {
+    writeFragment({ data, fragment, fragmentName, ...options }) {
+        const id = options.from !== undefined ? this.toCacheId(options.from) : options.id;
         return this.write(Object.assign(options, {
             query: this.getFragmentDoc(fragment, fragmentName),
             dataId: id,
@@ -182,8 +327,27 @@ export class ApolloCache {
             },
         });
     }
+    toCacheId(from) {
+        return typeof from === "string" ? from : this.identify(from);
+    }
 }
 if (__DEV__) {
     ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;
 }
+const nullResult = Object.freeze({
+    data: null,
+    dataState: "complete",
+    complete: true,
+});
+const nullObservable = Object.assign(new Observable((observer) => {
+    observer.next(nullResult);
+}), { dirty: false, getCurrentResult: () => nullResult });
+const emptyArrayResult = Object.freeze({
+    data: [],
+    dataState: "complete",
+    complete: true,
+});
+const emptyArrayObservable = Object.assign(new Observable((observer) => {
+    observer.next(emptyArrayResult);
+}), { getCurrentResult: () => emptyArrayResult });
 //# sourceMappingURL=cache.js.map