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

package/cache/inmemory/key-extractor.js

@@ -34,7 +34,7 @@ export function keyFieldsFnFromSpecifier(specifier) {
                     // context.readField for this extraction.
                     extracted = extractKeyPath(object, schemaKeyPath, extractKey);
                 }
-                invariant(extracted !== void 0, 102, schemaKeyPath.join("."), object);
+                invariant(extracted !== void 0, 107, schemaKeyPath.join("."), object);
                 return extracted;
             }));
             return `${context.typename}:${JSON.stringify(keyObject)}`;

package/cache/inmemory/policies.js

@@ -220,7 +220,7 @@ export class Policies {
         const rootId = "ROOT_" + which.toUpperCase();
         const old = this.rootTypenamesById[rootId];
         if (typename !== old) {
-            invariant(!old || old === which, 103, which);
+            invariant(!old || old === which, 108, which);
             // First, delete any old __typename associated with this rootId from
             // rootIdsByTypename.
             if (old)
@@ -363,7 +363,7 @@ export class Policies {
                 if (supertypeSet.has(supertype)) {
                     if (!typenameSupertypeSet.has(supertype)) {
                         if (checkingFuzzySubtypes) {
-                            __DEV__ && invariant.warn(104, typename, supertype);
+                            __DEV__ && invariant.warn(109, typename, supertype);
                         }
                         // Record positive results for faster future lookup.
                         // Unfortunately, we cannot safely cache negative results,
@@ -615,7 +615,7 @@ export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, vari
         }
     }
     if (__DEV__ && options.from === void 0) {
-        __DEV__ && invariant.warn(105, stringifyForDisplay(Array.from(readFieldArgs)));
+        __DEV__ && invariant.warn(110, stringifyForDisplay(Array.from(readFieldArgs)));
     }
     if (void 0 === options.variables) {
         options.variables = variables;
@@ -625,7 +625,7 @@ export function normalizeReadFieldOptions(readFieldArgs, objectOrReference, vari
 function makeMergeObjectsFunction(store) {
     return function mergeObjects(existing, incoming) {
         if (isArray(existing) || isArray(incoming)) {
-            throw newInvariantError(106);
+            throw newInvariantError(111);
         }
         // These dynamic checks are necessary because the parameters of a
         // custom merge function can easily have the any type, so the type

package/cache/inmemory/readFromStore.js

@@ -194,7 +194,7 @@ export class StoreReader {
             else {
                 const fragment = getFragmentFromSelection(selection, context.lookupFragment);
                 if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {
-                    throw newInvariantError(107, selection.name.value);
+                    throw newInvariantError(112, selection.name.value);
                 }
                 if (fragment && policies.fragmentMatches(fragment, typename)) {
                     fragment.selectionSet.selections.forEach(workSet.add, workSet);
@@ -277,7 +277,7 @@ function assertSelectionSetForIdValue(store, field, fieldValue) {
             if (isNonNullObject(value)) {
                 invariant(
                     !isReference(value),
-                    108,
+                    113,
                     getTypenameFromStoreObject(store, value),
                     field.name.value
                 );

package/cache/inmemory/writeToStore.js

@@ -68,7 +68,7 @@ export class StoreWriter {
             path: [],
         });
         if (!isReference(ref)) {
-            throw newInvariantError(109, result);
+            throw newInvariantError(114, result);
         }
         // So far, the store has not been modified, so now it's time to process
         // context.incomingById and merge those incoming fields into context.store.
@@ -230,7 +230,7 @@ export class StoreWriter {
                 // provide a default value, so its absence from the written data should
                 // not be cause for alarm.
                 !policies.getReadFunction(typename, field.name.value)) {
-                invariant.error(110, resultKeyNameFromField(field), result);
+                invariant.error(115, resultKeyNameFromField(field), result);
             }
         });
         // Identify the result object, even if dataId was already provided,
@@ -378,7 +378,7 @@ export class StoreWriter {
                 else {
                     const fragment = getFragmentFromSelection(selection, context.lookupFragment);
                     if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {
-                        throw newInvariantError(111, selection.name.value);
+                        throw newInvariantError(116, selection.name.value);
                     }
                     if (fragment &&
                         policies.fragmentMatches(fragment, typename, result, context.variables)) {
@@ -550,7 +550,7 @@ function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
             }
         });
     }
-    __DEV__ && invariant.warn(112, fieldName, parentType, childTypenames.length ?
+    __DEV__ && invariant.warn(117, fieldName, parentType, childTypenames.length ?
         "either ensure all objects of type " +
             childTypenames.join(" and ") +
             " have an ID or a custom merge function, or "

package/core/ApolloClient.d.ts

@@ -12,7 +12,8 @@ import type { LazyType, OptionWithFallback, SignatureStyle, VariablesOption, var
 import { getApolloClientMemoryInternals } from "@apollo/client/utilities/internal";
 import type { DeclareDefaultOptions, DefaultOptions } from "./defaultOptions.js";
 import type { ObservableQuery } from "./ObservableQuery.js";
-import type { DefaultContext, ErrorLike, InternalRefetchQueriesInclude, InternalRefetchQueriesResult, MutationQueryReducersMap, MutationUpdaterFunction, NormalizedExecutionResult, OnQueryUpdated, OperationVariables, RefetchQueriesInclude, RefetchQueriesPromiseResults, SubscriptionObservable, TypedDocumentNode } from "./types.js";
+import type { RefetchEventManager } from "./RefetchEventManager.js";
+import type { DefaultContext, ErrorLike, InternalRefetchQueriesInclude, InternalRefetchQueriesResult, MutationQueryReducersMap, MutationUpdaterFunction, NormalizedExecutionResult, OnQueryUpdated, OperationVariables, RefetchOn, RefetchQueriesInclude, RefetchQueriesPromiseResults, SubscriptionObservable, TypedDocumentNode } from "./types.js";
 import type { ErrorPolicy, FetchPolicy, MutationFetchPolicy, NextFetchPolicyContext, RefetchWritePolicy, WatchQueryFetchPolicy } from "./watchQueryOptions.js";
 /**
 * @knipignore
@@ -28,6 +29,13 @@ export interface ReferenceToAvoidDroppingImportOnBuild {
 }
 export declare namespace ApolloClient {
     export type { DeclareDefaultOptions, DefaultOptions };
+    export namespace DocumentationTypes {
+        interface DefaultOptions {
+            watchQuery?: Partial<ApolloClient.WatchQueryOptions<any, any>>;
+            query?: Partial<ApolloClient.QueryOptions<any, any>>;
+            mutate?: Partial<ApolloClient.MutateOptions<any, any, any>>;
+        }
+    }
     export interface Options extends InternalTypes.DefaultOptionsParentObject {
         /**
          * An `ApolloLink` instance to serve as Apollo Client's network layer. For more information, see [Advanced HTTP networking](https://www.apollographql.com/docs/react/networking/advanced-http-networking/).
@@ -99,6 +107,11 @@ export declare namespace ApolloClient {
          * Do not pass in experiments that are not provided by Apollo.
          */
         experiments?: ApolloClient.Experiment[];
+        /**
+         * The `RefetchEventManager` instance that manages automatic refetches for
+         * the client.
+         */
+        refetchEventManager?: RefetchEventManager;
     }
     export interface DevtoolsOptions {
         /**
@@ -216,24 +229,118 @@ export declare namespace ApolloClient {
         */
         mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
     } & VariablesOption<NoInfer<TVariables>>;
-    export interface MutateResult<TData = unknown> {
-        /**
-        * 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;
+    export namespace mutate {
+        interface DefaultOptions extends ApolloClient.DefaultOptions.Mutate.Calculated {
+        }
+        type ResultForOptions<TData, TVariables extends OperationVariables, TCache extends ApolloCache, TOptions extends Record<string, unknown> | MutateOptions<any, TVariables, TCache>> = LazyType<MutateResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
+        namespace Signatures {
+            interface Classic {
+                /**
+                * @deprecated Avoid manually specifying generics on `client.mutate`.
+                * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your mutation results.
+                *
+                *
+                * This resolves a single mutation according to the options specified and returns a
+                * Promise which is either resolved with the resulting data or rejected with an
+                * error. In some cases both `data` and `errors` might be undefined, for example
+                * when `errorPolicy` is set to `'ignore'`.
+                * 
+                * It takes options as an object with the following keys and values:
+                */
+                <TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
+            }
+            interface Modern {
+                /**
+                * This resolves a single mutation according to the options specified and returns a
+                * Promise which is either resolved with the resulting data or rejected with an
+                * error. In some cases both `data` and `errors` might be undefined, for example
+                * when `errorPolicy` is set to `'ignore'`.
+                * 
+                * It takes options as an object with the following keys and values:
+                */
+                <TData, TVariables extends OperationVariables, TCache extends ApolloCache, TOptions extends ApolloClient.MutateOptions<NoInfer<TData>, NoInfer<TVariables>, TCache> & VariablesOption<TVariables & {
+                    [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
+                }>>(options: TOptions & {
+                    mutation: TypedDocumentNode<TData, TVariables>;
+                }): Promise<ApolloClient.mutate.ResultForOptions<TData, TVariables, TCache, TOptions>>;
+            }
+            type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+        }
         /**
-        * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+        * This resolves a single mutation according to the options specified and returns a
+        * Promise which is either resolved with the resulting data or rejected with an
+        * error. In some cases both `data` and `errors` might be undefined, for example
+        * when `errorPolicy` is set to `'ignore'`.
         * 
-        * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+        * It takes options as an object with the following keys and values:
         */
-        error?: ErrorLike;
+        interface Signature extends Signatures.Evaluated {
+        }
+    }
+    export type MutateResultMap<TData = unknown> = {
+        none: {
+            /**
+            * 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;
+            /**
+            * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            */
+            error?: never;
+        };
+        all: {
+            /**
+            * 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;
+            /**
+            * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            */
+            error?: ErrorLike;
+        };
+        ignore: {
+            /**
+            * 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;
+            /**
+            * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            */
+            error?: never;
+        };
+        undefined: {
+            /**
+            * 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;
+            /**
+            * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            */
+            error?: ErrorLike;
+        };
+    };
+    export type MutateResult<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = MutateResultMap<TData>[`${TErrorPolicy}`] & {
         /**
         * Custom extensions returned from the GraphQL server
         */
         extensions?: Record<string, unknown>;
-    }
+    };
     /**
      * Query options.
      */
@@ -271,7 +378,7 @@ export declare namespace ApolloClient {
         */
         fetchPolicy?: FetchPolicy;
     } & VariablesOption<NoInfer<TVariables>>;
-    export type QueryResultMap<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = {
+    export type QueryResultMap<TData = unknown> = {
         none: {
             /**
             * An object containing the result of your GraphQL query after it completes.
@@ -349,7 +456,7 @@ export declare namespace ApolloClient {
             error?: ErrorLike;
         };
     };
-    export type QueryResult<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = QueryResultMap<TData, TErrorPolicy>[`${TErrorPolicy}`];
+    export type QueryResult<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = QueryResultMap<TData>[`${TErrorPolicy}`];
     export namespace query {
         interface DefaultOptions extends ApolloClient.DefaultOptions.Query.Calculated {
         }
@@ -598,6 +705,25 @@ export declare namespace ApolloClient {
         */
         query: DocumentNode | TypedDocumentNode<TData, TVariables>;
         /**
+        * Determines whether events trigger refetches for the query. Provide an
+        * object mapping each refetch event to `true` (enable), `false` (disable)
+        * or a callback function that returns `true`/`false` to control individual
+        * events. Provide `false` to disable all automatic refetch events for this
+        * query. Provide `true` to enable all automatic refetch events for this query.
+        * Provide a callback function to perform additional logic to determine
+        * whether to enable or disable a refetch for a query.
+        * 
+        * `@remarks`
+        * `refetchOn` inherits from `defaultOptions.watchQuery.refetchOn`. If
+        * `defaultOptions.watchQuery.refetchOn` is not set, all refetch events are
+        * enabled by default.
+        * 
+        * This option only has an effect when the client is configured with a
+        * `refetchEventManager`.
+        * @docGroup 1. Operation options
+        */
+        refetchOn?: RefetchOn.Option;
+        /**
         * @internal This API is meant for framework integrations only.
         * Do not use for everyday use.
         *
@@ -827,6 +953,15 @@ export declare namespace ApolloClient {
          * server at all or just resolve from the cache, etc.
          */
         function query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
+        /**
+         * This resolves a single mutation according to the options specified and returns a
+         * Promise which is either resolved with the resulting data or rejected with an
+         * error. In some cases both `data` and `errors` might be undefined, for example
+         * when `errorPolicy` is set to `'ignore'`.
+         *
+         * It takes options as an object with the following keys and values:
+         */
+        function mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
     }
 }
 /**
@@ -855,6 +990,7 @@ export declare class ApolloClient {
     queryDeduplication: boolean;
     defaultOptions: ApolloClient.DefaultOptions;
     readonly devtoolsConfig: ApolloClient.DevtoolsOptions;
+    readonly refetchEventManager: RefetchEventManager | undefined;
     private queryManager;
     private devToolsHookCb?;
     private resetStoreCallbacks;
@@ -907,6 +1043,7 @@ export declare class ApolloClient {
      * - Unsubscribes all active `ObservableQuery` instances by emitting a `completed` event
      * - Rejects all currently running queries with "QueryManager stopped while query was in flight"
      * - Removes all queryRefs from the suspense cache
+     * - Disconnects the `RefetchEventManager` if configured.
      */
     stop(): void;
     /**
@@ -940,14 +1077,14 @@ export declare class ApolloClient {
     */
     query: ApolloClient.query.Signature;
     /**
-     * This resolves a single mutation according to the options specified and returns a
-     * Promise which is either resolved with the resulting data or rejected with an
-     * error. In some cases both `data` and `errors` might be undefined, for example
-     * when `errorPolicy` is set to `'ignore'`.
-     *
-     * It takes options as an object with the following keys and values:
-     */
-    mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
+    * This resolves a single mutation according to the options specified and returns a
+    * Promise which is either resolved with the resulting data or rejected with an
+    * error. In some cases both `data` and `errors` might be undefined, for example
+    * when `errorPolicy` is set to `'ignore'`.
+    * 
+    * It takes options as an object with the following keys and values:
+    */
+    mutate: ApolloClient.mutate.Signature;
     /**
      * This subscribes to a graphql subscription according to the options specified and returns an
      * `Observable` which either emits received data or an error.

package/core/ApolloClient.js

@@ -4,7 +4,7 @@ import { NotImplementedHandler } from "@apollo/client/incremental";
 import { execute } from "@apollo/client/link";
 import { DocumentTransform } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { checkDocument, compact, getApolloClientMemoryInternals, mapObservableFragmentMemoized, mergeOptions, removeMaskedFragmentSpreads, } from "@apollo/client/utilities/internal";
+import { checkDocument, compact, getApolloClientMemoryInternals, getOperationName, mapObservableFragmentMemoized, mergeOptions, removeMaskedFragmentSpreads, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 import { version } from "../version.js";
 import { QueryManager } from "./QueryManager.js";
@@ -39,6 +39,7 @@ export class ApolloClient {
     queryDeduplication;
     defaultOptions;
     devtoolsConfig;
+    refetchEventManager;
     queryManager;
     devToolsHookCb;
     resetStoreCallbacks = [];
@@ -73,7 +74,7 @@ export class ApolloClient {
             invariant(options.cache, 68);
             invariant(options.link, 69);
         }
-        const { cache, documentTransform, ssrMode = false, ssrForceFetchDelay = 0, queryDeduplication = true, defaultOptions, defaultContext, assumeImmutableResults = cache.assumeImmutableResults, localState, devtools, dataMasking, link, incrementalHandler = new NotImplementedHandler(), experiments = [], } = options;
+        const { cache, documentTransform, ssrMode = false, ssrForceFetchDelay = 0, queryDeduplication = true, defaultOptions, defaultContext, assumeImmutableResults = cache.assumeImmutableResults, localState, devtools, dataMasking, link, incrementalHandler = new NotImplementedHandler(), experiments = [], refetchEventManager, } = options;
         this.link = link;
         this.cache = cache;
         this.queryDeduplication = queryDeduplication;
@@ -123,6 +124,8 @@ export class ApolloClient {
         if (this.devtoolsConfig.enabled)
             this.connectToDevTools();
         experiments.forEach((experiment) => experiment.call(this, options));
+        this.refetchEventManager = refetchEventManager;
+        this.refetchEventManager?.connect(this);
     }
     connectToDevTools() {
         if (typeof window === "undefined") {
@@ -193,9 +196,11 @@ export class ApolloClient {
      * - Unsubscribes all active `ObservableQuery` instances by emitting a `completed` event
      * - Rejects all currently running queries with "QueryManager stopped while query was in flight"
      * - Removes all queryRefs from the suspense cache
+     * - Disconnects the `RefetchEventManager` if configured.
      */
     stop() {
         this.queryManager.stop();
+        this.refetchEventManager?.disconnect(this);
     }
     /**
      * This watches the cache store of the query according to the options specified and
@@ -218,7 +223,34 @@ export class ApolloClient {
      */
     watchQuery(options) {
         if (this.defaultOptions.watchQuery) {
+            const defaultRefetchOn = this.defaultOptions.watchQuery.refetchOn;
+            const mergedRefetchOn = (options.refetchOn &&
+                typeof options.refetchOn === "object" &&
+                defaultRefetchOn &&
+                typeof defaultRefetchOn === "object") ?
+                { ...defaultRefetchOn, ...options.refetchOn }
+                : undefined;
             options = mergeOptions(this.defaultOptions.watchQuery, options);
+            if (mergedRefetchOn) {
+                options.refetchOn = mergedRefetchOn;
+            }
+        }
+        if (__DEV__) {
+            const { refetchOn, query } = options;
+            const { refetchEventManager } = this;
+            if (refetchOn) {
+                const operationName = getOperationName(query, "(anonymous)");
+                if (!refetchEventManager) {
+                    __DEV__ && invariant.warn(70, operationName);
+                }
+                else if (typeof refetchOn === "object") {
+                    Object.keys(refetchOn).forEach((source) => {
+                        if (!refetchEventManager.hasSource(source)) {
+                            __DEV__ && invariant.warn(71, source, operationName);
+                        }
+                    });
+                }
+            }
         }
         return this.queryManager.watchQuery(options);
     }
@@ -236,37 +268,37 @@ export class ApolloClient {
             options = mergeOptions(this.defaultOptions.query, options);
         }
         if (__DEV__) {
-            invariant(options.fetchPolicy !== "cache-and-network", 70);
-            invariant(options.fetchPolicy !== "standby", 71);
-            invariant(options.query, 72);
-            invariant(options.query.kind === "Document", 73);
-            invariant(!options.returnPartialData, 74);
-            invariant(!options.pollInterval, 75);
-            invariant(!options.notifyOnNetworkStatusChange, 76);
+            invariant(options.fetchPolicy !== "cache-and-network", 72);
+            invariant(options.fetchPolicy !== "standby", 73);
+            invariant(options.query, 74);
+            invariant(options.query.kind === "Document", 75);
+            invariant(!options.returnPartialData, 76);
+            invariant(!options.pollInterval, 77);
+            invariant(!options.notifyOnNetworkStatusChange, 78);
         }
         return this.queryManager.query(options);
     };
     /**
-     * This resolves a single mutation according to the options specified and returns a
-     * Promise which is either resolved with the resulting data or rejected with an
-     * error. In some cases both `data` and `errors` might be undefined, for example
-     * when `errorPolicy` is set to `'ignore'`.
-     *
-     * It takes options as an object with the following keys and values:
-     */
-    mutate(options) {
+    * This resolves a single mutation according to the options specified and returns a
+    * Promise which is either resolved with the resulting data or rejected with an
+    * error. In some cases both `data` and `errors` might be undefined, for example
+    * when `errorPolicy` is set to `'ignore'`.
+    * 
+    * It takes options as an object with the following keys and values:
+    */
+    mutate = (options) => {
         const optionsWithDefaults = mergeOptions(compact({
             fetchPolicy: "network-only",
             errorPolicy: "none",
         }, this.defaultOptions.mutate), options);
         if (__DEV__) {
-            invariant(optionsWithDefaults.mutation, 77);
+            invariant(optionsWithDefaults.mutation, 79);
             invariant(optionsWithDefaults.fetchPolicy === "network-only" ||
-                optionsWithDefaults.fetchPolicy === "no-cache", 78);
+                optionsWithDefaults.fetchPolicy === "no-cache", 80);
         }
         checkDocument(optionsWithDefaults.mutation, OperationTypeNode.MUTATION);
         return this.queryManager.mutate(optionsWithDefaults);
-    }
+    };
     /**
      * This subscribes to a graphql subscription according to the options specified and returns an
      * `Observable` which either emits received data or an error.
@@ -468,7 +500,7 @@ export class ApolloClient {
         // result.queries and result.results instead, you shouldn't have to worry
         // about preventing uncaught rejections for the Promise.all result.
         result.catch((error) => {
-            __DEV__ && invariant.debug(79, error);
+            __DEV__ && invariant.debug(81, error);
         });
         return result;
     }