@apollo/client 4.2.0-alpha.6 → 4.2.0-alpha.8

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # @apollo/client
 
+## 4.2.0-alpha.8
+
+### Patch Changes
+
+- [#13229](https://github.com/apollographql/apollo-client/pull/13229) [`9a7f65a`](https://github.com/apollographql/apollo-client/commit/9a7f65a0059433c83307ef2d8117dac67947d791) Thanks [@jerelmiller](https://github.com/jerelmiller)! - Fix `refetchOn` merging when `defaultOptions.watchQuery.refetchOn` is set to a non-object value (`false`, `true`, or a function) and the per-query `refetchOn` is an object. Previously the per-query object completely replaced the default so unspecified events fell back to "enabled" regardless of the default.
+
+  The `defaultOptions` value now applies to any event the per-query object does not explicitly configure:
+
+  - `false` - unspecified events stay disabled
+  - `true` - unspecified events refetch
+  - Callback function - the function is called for unspecified events to determine whether to refetch
+
+  ```ts
+  const client = new ApolloClient({
+    // ...
+    defaultOptions: {
+      watchQuery: {
+        refetchOn: false,
+      },
+    },
+  });
+
+  // Only `windowFocus` refetches. Other events stay disabled per the default.
+  useQuery(QUERY, { refetchOn: { windowFocus: true } });
+  ```
+
+- [#13230](https://github.com/apollographql/apollo-client/pull/13230) [`b25b659`](https://github.com/apollographql/apollo-client/commit/b25b6593f5d968db505b127e7ff7f2bb2419d5ee) Thanks [@jerelmiller](https://github.com/jerelmiller)! - Add the ability to override the default event handler on `RefetchEventManager`. The default handler runs when no per-source handler is configured for an event. Provide a custom handler via the `defaultHandler` constructor option or the `setDefaultEventHandler` instance method.
+
+  ```ts
+  new RefetchEventManager({
+    defaultHandler: ({ client, matchesRefetchOn }) => {
+      return client.refetchQueries({
+        include: "all",
+        onQueryUpdated: matchesRefetchOn,
+      });
+    },
+  });
+  ```
+
+## 4.2.0-alpha.7
+
+### Minor Changes
+
+- [#13222](https://github.com/apollographql/apollo-client/pull/13222) [`b93c172`](https://github.com/apollographql/apollo-client/commit/b93c1723b4b7a9d1296ddd57035bc4fe39c8d971) Thanks [@jerelmiller](https://github.com/jerelmiller)! - Extend the `defaultOptions` type-safety work to `preloadQuery` (returned from `createQueryPreloader`). Defaults declared in `DeclareDefaultOptions.WatchQuery` now work with `preloadQuery` to ensure the `PreloadedQueryRef`'s data states are correctly set.
+
+  ```ts
+  // apollo.d.ts
+  import "@apollo/client";
+
+  declare module "@apollo/client" {
+    namespace ApolloClient {
+      namespace DeclareDefaultOptions {
+        interface WatchQuery {
+          errorPolicy: "all";
+        }
+      }
+    }
+  }
+  ```
+
+  ```ts
+  const preloadQuery = createQueryPreloader(client);
+  const queryRef = preloadQuery(QUERY);
+  //    ^? PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "empty">
+  ```
+
 ## 4.2.0-alpha.6
 
 ### Patch Changes

package/__cjs/core/ApolloClient.cjs

@@ -229,22 +229,42 @@ class ApolloClient {
      * a description of store reactivity.
      */
     watchQuery(options) {
+        const { refetchOn } = options;
         if (this.defaultOptions.watchQuery) {
+            // Capture the default `refetchOn` at the time of the `watchQuery`
+            // call so that it is unaffected even if defaultOptions.refetchOn is
+            // mutated later.
             const defaultRefetchOn = this.defaultOptions.watchQuery.refetchOn;
-            const mergedRefetchOn = (options.refetchOn &&
-                typeof options.refetchOn === "object" &&
-                defaultRefetchOn &&
-                typeof defaultRefetchOn === "object") ?
-                { ...defaultRefetchOn, ...options.refetchOn }
-                : undefined;
+            let mergedRefetchOn;
+            if (refetchOn && typeof refetchOn === "object") {
+                if (typeof defaultRefetchOn === "object") {
+                    mergedRefetchOn = { ...defaultRefetchOn, ...refetchOn };
+                }
+                else if (defaultRefetchOn != null) {
+                    // We set the merged `refetchOn` option to a callback function in case
+                    // the client hasn't connected to a RefetchEventManager yet, or
+                    // sources are added to the manager after watchQuery is called. This
+                    // ensures we can handle any registered source regardless of when it
+                    // was registered.
+                    mergedRefetchOn = (ctx) => {
+                        const value = refetchOn[ctx.source] ?? defaultRefetchOn;
+                        if (typeof value === "function") {
+                            return value(ctx);
+                        }
+                        return value;
+                    };
+                }
+            }
             options = (0, internal_1.mergeOptions)(this.defaultOptions.watchQuery, options);
             if (mergedRefetchOn) {
                 options.refetchOn = mergedRefetchOn;
             }
         }
         if (environment_1.__DEV__) {
-            const { refetchOn, query } = options;
+            const { query } = options;
             const { refetchEventManager } = this;
+            // Note: refetchOn evaluates the original refetchOn value, not the merged
+            // refetchOn value.
             if (refetchOn) {
                 const operationName = (0, internal_1.getOperationName)(query, "(anonymous)");
                 if (!refetchEventManager) {