@apollo/client 4.1.0-alpha.2 → 4.1.0-alpha.4

package/__cjs/core/ApolloClient.d.cts

@@ -214,7 +214,9 @@ export declare namespace ApolloClient {
     } & VariablesOption<NoInfer<TVariables>>;
     interface MutateResult<TData = unknown> {
         /**
-        * The data returned from your mutation. Can be `undefined` if `ignoreResults` is `true`.
+        * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+        * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+        * but not `data` or a network error is returned.
         */
         data: TData | undefined;
         /**
@@ -275,7 +277,7 @@ export declare namespace ApolloClient {
         */
         data: TData | undefined;
         /**
-        * A single ErrorLike object describing the error that occured during the latest
+        * A single ErrorLike object describing the error that occurred during the latest
         * query execution.
         * 
         * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
@@ -365,7 +367,9 @@ export declare namespace ApolloClient {
     } & VariablesOption<NoInfer<TVariables>>;
     interface SubscribeResult<TData = unknown> {
         /**
-        * The data returned from your mutation. Can be `undefined` if `ignoreResults` is `true`.
+        * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+        * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+        * but not `data` or a network error is returned.
         */
         data: TData | undefined;
         /**
@@ -380,7 +384,13 @@ export declare namespace ApolloClient {
         extensions?: Record<string, unknown>;
     }
     type WatchFragmentOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = ApolloCache.WatchFragmentOptions<TData, TVariables>;
-    type WatchFragmentResult<TData = unknown> = ApolloCache.WatchFragmentResult<TData>;
+    type WatchFragmentResult<TData = unknown> = ApolloCache.WatchFragmentResult<MaybeMasked<TData>>;
+    interface ObservableFragment<TData = unknown> extends Observable<ApolloClient.WatchFragmentResult<TData>> {
+        /**
+         * Return the current result for the fragment.
+         */
+        getCurrentResult: () => ApolloClient.WatchFragmentResult<TData>;
+    }
     /**
      * Watched query options.
      */
@@ -819,7 +829,86 @@ export declare class ApolloClient {
      * the cache to identify the fragment and optionally specify whether to react
      * to optimistic updates.
      */
-    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables>): Observable<ApolloClient.WatchFragmentResult<MaybeMasked<TData>>>;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: Array<NonNullable<ApolloCache.WatchFragmentFromValue<TData>>>;
+    }): ApolloClient.ObservableFragment<Array<TData>>;
+    /**
+    * 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: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: Array<null>;
+    }): ApolloClient.ObservableFragment<Array<null>>;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: Array<ApolloCache.WatchFragmentFromValue<TData>>;
+    }): ApolloClient.ObservableFragment<Array<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: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: null;
+    }): ApolloClient.ObservableFragment<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: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: NonNullable<ApolloCache.WatchFragmentFromValue<TData>>;
+    }): ApolloClient.ObservableFragment<TData>;
+    /**
+    * 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: ApolloClient.WatchFragmentOptions<TData, TVariables>): ApolloClient.ObservableFragment<TData | null>;
     /**
      * Tries to read some data from the store in the shape of the provided
      * GraphQL fragment without making a network request. This method will read a

package/__cjs/core/ObservableQuery.cjs

@@ -284,7 +284,7 @@ class ObservableQuery {
                     // not be notified about future cache changes with an equal `diff`.
                     // That would be the case if we are working with client-only fields
                     // that are forced or with `exports` fields that might change, causing
-                    // local resovlers to return a new result.
+                    // local resolvers to return a new result.
                     // This is based on an implementation detail of `InMemoryCache`, which
                     // is not optimal - but the only alternative to this would be to
                     // resubscribe to the cache asynchonouly, which would bear the risk of
@@ -464,6 +464,9 @@ class ObservableQuery {
                     finalize();
                 }
                 if (isCached) {
+                    // Separately getting a diff here before the batch - `onWatchUpdated` might be
+                    // called with an `undefined` `lastDiff` on the watcher if the cache was just subscribed to.
+                    const lastDiff = this.getCacheDiff();
                     // Performing this cache update inside a cache.batch transaction ensures
                     // any affected cache.watch watchers are notified at most once about any
                     // updates. Most watchers will be using the QueryInfo class, which
@@ -496,7 +499,8 @@ class ObservableQuery {
                             }
                         },
                         onWatchUpdated: (watch, diff) => {
-                            if (watch.watcher === this) {
+                            if (watch.watcher === this &&
+                                !(0, equality_1.equal)(diff.result, lastDiff.result)) {
                                 wasUpdated = true;
                                 const lastResult = this.getCurrentResult();
                                 // Let the cache watch from resubscribeCache handle the final
@@ -1021,7 +1025,7 @@ class ObservableQuery {
             .then((result) => (0, internal_1.toQueryResult)(this.maskResult(result)))
             .finally(() => {
             if (!this.hasObservers() && this.activeOperations.size === 0) {
-                // If `reobserve` was called on a query without any obervers,
+                // If `reobserve` was called on a query without any observers,
                 // the teardown logic would never be called, so we need to
                 // call it here to ensure the query is properly torn down.
                 this.tearDownQuery();
@@ -1129,7 +1133,7 @@ class ObservableQuery {
                 !this.activeOperations.size)) {
             const diff = this.getCacheDiff();
             if (
-            // `fromOptimisticTransaction` is not avaiable through the `cache.diff`
+            // `fromOptimisticTransaction` is not available through the `cache.diff`
             // code path, so we need to check it this way
             (0, equality_1.equal)(diff.result, this.getCacheDiff({ optimistic: false }).result)) {
                 //If this diff did not come from an optimistic transaction