@apollo/client 4.1.0-alpha.1 → 4.1.0-alpha.3

package/__cjs/cache/core/cache.d.cts

@@ -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.cjs";
 import type { MissingTree } from "./types/common.cjs";
 export type Transaction = (c: ApolloCache) => void;
 export declare namespace ApolloCache {
+    /**
+     * Acceptable values provided to the `from` option for `watchFragment`.
+     */
+    type WatchFragmentFromValue<TData> = StoreObject | Reference | FragmentType<NoInfer<TData>> | string | null;
     /**
      * Watched fragment options.
      */
@@ -28,7 +32,7 @@ export declare namespace ApolloCache {
          *
          * @docGroup 1. Required options
          */
-        from: StoreObject | Reference | FragmentType<NoInfer<TData>> | string;
+        from: ApolloCache.WatchFragmentFromValue<TData> | Array<ApolloCache.WatchFragmentFromValue<TData>>;
         /**
          * 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;
@@ -138,23 +180,30 @@ 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<NonNullable<ApolloCache.WatchFragmentFromValue<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.WatchFragmentFromValue<TData>>;
+    }): 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: NonNullable<ApolloCache.WatchFragmentFromValue<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.

package/__cjs/cache/inmemory/inMemoryCache.cjs

@@ -411,7 +411,18 @@ class InMemoryCache extends cache_js_1.ApolloCache {
     }
     broadcastWatches(options) {
         if (!this.txCount) {
-            this.watches.forEach((c) => this.maybeBroadcastWatch(c, options));
+            const prevOnAfter = this.onAfterBroadcast;
+            const callbacks = new Set();
+            this.onAfterBroadcast = (cb) => {
+                callbacks.add(cb);
+            };
+            try {
+                this.watches.forEach((c) => this.maybeBroadcastWatch(c, options));
+                callbacks.forEach((cb) => cb());
+            }
+            finally {
+                this.onAfterBroadcast = prevOnAfter;
+            }
         }
     }
     addFragmentsToDocument(document) {