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

package/__cjs/react/query-preloader/createQueryPreloader.d.cts

@@ -1,6 +1,6 @@
 import type { ApolloClient, DefaultContext, DocumentNode, ErrorPolicy, OperationVariables, RefetchOn, RefetchWritePolicy, TypedDocumentNode, WatchQueryFetchPolicy } from "@apollo/client";
 import type { PreloadedQueryRef } from "@apollo/client/react";
-import type { NoInfer, VariablesOption } from "@apollo/client/utilities/internal";
+import type { NoInfer, OptionWithFallback, SignatureStyle, VariablesOption } from "@apollo/client/utilities/internal";
 export type PreloadQueryFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
 export type PreloadQueryOptions<TVariables extends OperationVariables = OperationVariables> = {
     /**
@@ -93,128 +93,7 @@ export type PreloadQueryOptions<TVariables extends OperationVariables = Operatio
  * }
  * ```
  */
-export interface PreloadQueryFunction {
-    /**
-    * A function that will begin loading a query when called. It's result can be
-    * read by `useReadQuery` which will suspend until the query is loaded.
-    * This is useful when you want to start loading a query as early as possible
-    * outside of a React component.
-    * 
-    * @example
-    * 
-    * ```js
-    * const preloadQuery = createQueryPreloader(client);
-    * const queryRef = preloadQuery(query, { variables, ...otherOptions });
-    * 
-    * function App() {
-    *   return (
-    *     <Suspense fallback={<div>Loading</div>}>
-    *       <MyQuery />
-    *     </Suspense>
-    *   );
-    * }
-    * 
-    * function MyQuery() {
-    *   const { data } = useReadQuery(queryRef);
-    * 
-    *   // do something with `data`
-    * }
-    * ```
-    */
-    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
-        returnPartialData: true;
-        errorPolicy: "ignore" | "all";
-    }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
-    /**
-    * A function that will begin loading a query when called. It's result can be
-    * read by `useReadQuery` which will suspend until the query is loaded.
-    * This is useful when you want to start loading a query as early as possible
-    * outside of a React component.
-    * 
-    * @example
-    * 
-    * ```js
-    * const preloadQuery = createQueryPreloader(client);
-    * const queryRef = preloadQuery(query, { variables, ...otherOptions });
-    * 
-    * function App() {
-    *   return (
-    *     <Suspense fallback={<div>Loading</div>}>
-    *       <MyQuery />
-    *     </Suspense>
-    *   );
-    * }
-    * 
-    * function MyQuery() {
-    *   const { data } = useReadQuery(queryRef);
-    * 
-    *   // do something with `data`
-    * }
-    * ```
-    */
-    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
-        errorPolicy: "ignore" | "all";
-    }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "empty">;
-    /**
-    * A function that will begin loading a query when called. It's result can be
-    * read by `useReadQuery` which will suspend until the query is loaded.
-    * This is useful when you want to start loading a query as early as possible
-    * outside of a React component.
-    * 
-    * @example
-    * 
-    * ```js
-    * const preloadQuery = createQueryPreloader(client);
-    * const queryRef = preloadQuery(query, { variables, ...otherOptions });
-    * 
-    * function App() {
-    *   return (
-    *     <Suspense fallback={<div>Loading</div>}>
-    *       <MyQuery />
-    *     </Suspense>
-    *   );
-    * }
-    * 
-    * function MyQuery() {
-    *   const { data } = useReadQuery(queryRef);
-    * 
-    *   // do something with `data`
-    * }
-    * ```
-    */
-    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
-        returnPartialData: true;
-    }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial">;
-    /**
-    * A function that will begin loading a query when called. It's result can be
-    * read by `useReadQuery` which will suspend until the query is loaded.
-    * This is useful when you want to start loading a query as early as possible
-    * outside of a React component.
-    * 
-    * @example
-    * 
-    * ```js
-    * const preloadQuery = createQueryPreloader(client);
-    * const queryRef = preloadQuery(query, { variables, ...otherOptions });
-    * 
-    * function App() {
-    *   return (
-    *     <Suspense fallback={<div>Loading</div>}>
-    *       <MyQuery />
-    *     </Suspense>
-    *   );
-    * }
-    * 
-    * function MyQuery() {
-    *   const { data } = useReadQuery(queryRef);
-    * 
-    *   // do something with `data`
-    * }
-    * ```
-    */
-    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-        options?: PreloadQueryOptions<NoInfer<TVariables>>
-    ] : [options: PreloadQueryOptions<NoInfer<TVariables>>]): PreloadedQueryRef<TData, TVariables, "complete" | "streaming">;
+export interface PreloadQueryFunction extends PreloadQueryFunction.Signatures.Evaluated {
     /**
      * A function that returns a promise that resolves when the query has finished
      * loading. The promise resolves with the `QueryReference` itself.
@@ -253,6 +132,399 @@ export interface PreloadQueryFunction {
      */
     toPromise<TQueryRef extends PreloadedQueryRef<any, any, any>>(queryRef: TQueryRef): Promise<TQueryRef>;
 }
+export declare namespace PreloadQueryFunction {
+    interface DefaultOptions extends ApolloClient.DefaultOptions.WatchQuery.Calculated {
+    }
+    namespace DocumentationTypes {
+        /**
+        * @deprecated Avoid manually specifying generics on `preloadQuery`.
+        * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+        *
+        *
+        * A function that will begin loading a query when called. It's result can be
+        * read by `useReadQuery` which will suspend until the query is loaded.
+        * This is useful when you want to start loading a query as early as possible
+        * outside of a React component.
+        * 
+        * @example
+        * 
+        * ```js
+        * const preloadQuery = createQueryPreloader(client);
+        * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+        * 
+        * function App() {
+        *   return (
+        *     <Suspense fallback={<div>Loading</div>}>
+        *       <MyQuery />
+        *     </Suspense>
+        *   );
+        * }
+        * 
+        * function MyQuery() {
+        *   const { data } = useReadQuery(queryRef);
+        * 
+        *   // do something with `data`
+        * }
+        * ```
+        */
+        interface PreloadQueryFunction_Deprecated extends PreloadQueryFunction {
+        }
+    }
+    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | PreloadQueryOptions<TVariables>> = TOptions extends any ? PreloadedQueryRef<TData, TVariables, ResultForOptions.States<TOptions, DefaultOptions>> : never;
+    namespace ResultForOptions {
+        type States<TOptions, TDefaultOptions extends DefaultOptions = DefaultOptions> = "complete" | "streaming" | (OptionWithFallback<TOptions, TDefaultOptions, "errorPolicy"> extends ("none") ? never : "empty") | (OptionWithFallback<TOptions, TDefaultOptions, "returnPartialData"> extends false ? never : "partial");
+    }
+    namespace Signatures {
+        interface Classic {
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                returnPartialData: true;
+                errorPolicy: "ignore" | "all";
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                errorPolicy: "ignore" | "all";
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "empty">;
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                returnPartialData: true;
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial">;
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: PreloadQueryOptions<NoInfer<TVariables>>
+            ] : [options: PreloadQueryOptions<NoInfer<TVariables>>]): PreloadedQueryRef<TData, TVariables, "complete" | "streaming">;
+            /**
+            * @deprecated Avoid manually specifying generics on `preloadQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                returnPartialData: true;
+                errorPolicy: "ignore" | "all";
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generics on `preloadQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                errorPolicy: "ignore" | "all";
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generics on `preloadQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                returnPartialData: true;
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial">;
+            /**
+            * @deprecated Avoid manually specifying generics on `preloadQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: PreloadQueryOptions<NoInfer<TVariables>>
+            ] : [options: PreloadQueryOptions<NoInfer<TVariables>>]): PreloadedQueryRef<TData, TVariables, "complete" | "streaming">;
+        }
+        /**
+        * A function that will begin loading a query when called. It's result can be
+        * read by `useReadQuery` which will suspend until the query is loaded.
+        * This is useful when you want to start loading a query as early as possible
+        * outside of a React component.
+        * 
+        * @example
+        * 
+        * ```js
+        * const preloadQuery = createQueryPreloader(client);
+        * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+        * 
+        * function App() {
+        *   return (
+        *     <Suspense fallback={<div>Loading</div>}>
+        *       <MyQuery />
+        *     </Suspense>
+        *   );
+        * }
+        * 
+        * function MyQuery() {
+        *   const { data } = useReadQuery(queryRef);
+        * 
+        *   // do something with `data`
+        * }
+        * ```
+        */
+        interface Modern {
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends never>(query: {} extends TVariables ? DocumentNode | TypedDocumentNode<TData, TVariables> : never): PreloadQueryFunction.ResultForOptions<TData, TVariables, Record<string, never>>;
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends PreloadQueryOptions<NoInfer<TVariables>> & VariablesOption<TVariables & {
+                [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
+            }>>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [options?: TOptions] : [options: TOptions]): PreloadQueryFunction.ResultForOptions<TData, TVariables, TOptions>;
+        }
+        type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+    }
+}
 /**
  * A higher order function that returns a `preloadQuery` function which
  * can be used to begin loading a query with the given `client`. This is useful

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.2.0-alpha.6";
+exports.version = "4.2.0-alpha.8";
 exports.build = "cjs";
 //# sourceMappingURL=version.cjs.map

package/core/ApolloClient.js

@@ -222,22 +222,42 @@ export 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 = mergeOptions(this.defaultOptions.watchQuery, options);
             if (mergedRefetchOn) {
                 options.refetchOn = mergedRefetchOn;
             }
         }
         if (__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 = getOperationName(query, "(anonymous)");
                 if (!refetchEventManager) {