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

package/core/ObservableQuery.js

@@ -276,7 +276,7 @@ export 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
@@ -456,6 +456,9 @@ export 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
@@ -488,7 +491,8 @@ export class ObservableQuery {
                             }
                         },
                         onWatchUpdated: (watch, diff) => {
-                            if (watch.watcher === this) {
+                            if (watch.watcher === this &&
+                                !equal(diff.result, lastDiff.result)) {
                                 wasUpdated = true;
                                 const lastResult = this.getCurrentResult();
                                 // Let the cache watch from resubscribeCache handle the final
@@ -1013,7 +1017,7 @@ export class ObservableQuery {
             .then((result) => 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();
@@ -1121,7 +1125,7 @@ export 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
             equal(diff.result, this.getCacheDiff({ optimistic: false }).result)) {
                 //If this diff did not come from an optimistic transaction