@apollo/client 4.0.0-alpha.20 → 4.0.0-alpha.21

package/__cjs/core/QueryManager.cjs

@@ -21,8 +21,6 @@ const invariant_1 = require("@apollo/client/utilities/invariant");
 const networkStatus_js_1 = require("./networkStatus.cjs");
 const ObservableQuery_js_1 = require("./ObservableQuery.cjs");
 const QueryInfo_js_1 = require("./QueryInfo.cjs");
-const { hasOwnProperty } = Object.prototype;
-const IGNORE = {};
 class QueryManager {
     defaultOptions;
     client;
@@ -51,7 +49,7 @@ class QueryManager {
      * All ObservableQueries that currently have at least one subscriber.
      */
     obsQueries = new Set();
-    // Maps from queryId strings to Promise rejection functions for
+    // Maps from queryInfo.id strings to Promise rejection functions for
     // currently active queries and fetches.
     // Use protected instead of private field so
     // @apollo/experimental-nextjs-app-support can access type info.
@@ -96,17 +94,17 @@ class QueryManager {
      */
     stop() {
         this.obsQueries.forEach((oq) => oq.stop());
-        this.cancelPendingFetches((0, invariant_1.newInvariantError)(82));
+        this.cancelPendingFetches((0, invariant_1.newInvariantError)(81));
     }
     cancelPendingFetches(error) {
         this.fetchCancelFns.forEach((cancel) => cancel(error));
         this.fetchCancelFns.clear();
     }
     async mutate({ mutation, variables, optimisticResponse, updateQueries, refetchQueries = [], awaitRefetchQueries = false, update: updateWithProxyFn, onQueryUpdated, fetchPolicy = this.defaultOptions.mutate?.fetchPolicy || "network-only", errorPolicy = this.defaultOptions.mutate?.errorPolicy || "none", keepRootFields, context, }) {
-        (0, invariant_1.invariant)(mutation, 83);
+        (0, invariant_1.invariant)(mutation, 82);
         (0, internal_1.checkDocument)(mutation, graphql_1.OperationTypeNode.MUTATION);
-        (0, invariant_1.invariant)(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 84);
-        const mutationId = this.generateMutationId();
+        (0, invariant_1.invariant)(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 83);
+        const queryInfo = new QueryInfo_js_1.QueryInfo(this);
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
         variables = this.getVariables(mutation, variables);
@@ -114,7 +112,7 @@ class QueryManager {
             if (environment_1.__DEV__) {
                 (0, invariant_1.invariant)(
                     this.localState,
-                    85,
+                    84,
                     (0, internal_1.getOperationName)(mutation, "(anonymous)")
                 );
             }
@@ -126,18 +124,19 @@ class QueryManager {
             });
         }
         const mutationStoreValue = this.mutationStore &&
-            (this.mutationStore[mutationId] = {
+            (this.mutationStore[queryInfo.id] = {
                 mutation,
                 variables,
                 loading: true,
                 error: null,
             });
         const isOptimistic = optimisticResponse &&
-            this.markMutationOptimistic(optimisticResponse, {
-                mutationId,
+            queryInfo.markMutationOptimistic(optimisticResponse, {
                 document: mutation,
                 variables,
-                fetchPolicy,
+                cacheWriteBehavior: fetchPolicy === "no-cache" ?
+                    0 /* CacheWriteBehavior.FORBID */
+                    : 2 /* CacheWriteBehavior.MERGE */,
                 errorPolicy,
                 context,
                 updateQueries,
@@ -167,19 +166,19 @@ class QueryManager {
                 if (errorPolicy === "ignore" && hasErrors) {
                     delete storeResult.errors;
                 }
-                return (0, rxjs_2.from)(this.markMutationResult({
-                    mutationId,
-                    result: storeResult,
+                return (0, rxjs_2.from)(queryInfo.markMutationResult(storeResult, {
                     document: mutation,
                     variables,
-                    fetchPolicy,
+                    cacheWriteBehavior: fetchPolicy === "no-cache" ?
+                        0 /* CacheWriteBehavior.FORBID */
+                        : 2 /* CacheWriteBehavior.MERGE */,
                     errorPolicy,
                     context,
                     update: updateWithProxyFn,
                     updateQueries,
                     awaitRefetchQueries,
                     refetchQueries,
-                    removeOptimistic: isOptimistic ? mutationId : void 0,
+                    removeOptimistic: isOptimistic ? queryInfo.id : void 0,
                     onQueryUpdated,
                     keepRootFields,
                 }));
@@ -216,7 +215,7 @@ class QueryManager {
                         mutationStoreValue.error = error;
                     }
                     if (isOptimistic) {
-                        this.cache.removeOptimistic(mutationId);
+                        this.cache.removeOptimistic(queryInfo.id);
                     }
                     this.broadcastQueries();
                     if (errorPolicy === "ignore") {
@@ -230,190 +229,8 @@ class QueryManager {
             });
         });
     }
-    markMutationResult(mutation, cache = this.cache) {
-        let { result } = mutation;
-        const cacheWrites = [];
-        const skipCache = mutation.fetchPolicy === "no-cache";
-        if (!skipCache && (0, QueryInfo_js_1.shouldWriteResult)(result, mutation.errorPolicy)) {
-            if (!(0, internal_1.isExecutionPatchIncrementalResult)(result)) {
-                cacheWrites.push({
-                    result: result.data,
-                    dataId: "ROOT_MUTATION",
-                    query: mutation.document,
-                    variables: mutation.variables,
-                });
-            }
-            if ((0, internal_1.isExecutionPatchIncrementalResult)(result) &&
-                (0, internal_1.isNonEmptyArray)(result.incremental)) {
-                const diff = cache.diff({
-                    id: "ROOT_MUTATION",
-                    // The cache complains if passed a mutation where it expects a
-                    // query, so we transform mutations and subscriptions to queries
-                    // (only once, thanks to this.transformCache).
-                    query: this.getDocumentInfo(mutation.document).asQuery,
-                    variables: mutation.variables,
-                    optimistic: false,
-                    returnPartialData: true,
-                });
-                let mergedData;
-                if (diff.result) {
-                    mergedData = (0, internal_1.mergeIncrementalData)(diff.result, result);
-                }
-                if (typeof mergedData !== "undefined") {
-                    // cast the ExecutionPatchResult to FetchResult here since
-                    // ExecutionPatchResult never has `data` when returned from the server
-                    result.data = mergedData;
-                    cacheWrites.push({
-                        result: mergedData,
-                        dataId: "ROOT_MUTATION",
-                        query: mutation.document,
-                        variables: mutation.variables,
-                    });
-                }
-            }
-            const { updateQueries } = mutation;
-            if (updateQueries) {
-                this.obsQueries.forEach((observableQuery) => {
-                    const queryName = observableQuery && observableQuery.queryName;
-                    if (!queryName || !hasOwnProperty.call(updateQueries, queryName)) {
-                        return;
-                    }
-                    const updater = updateQueries[queryName];
-                    const { query: document, variables } = observableQuery;
-                    // Read the current query result from the store.
-                    const { result: currentQueryResult, complete } = observableQuery.getCacheDiff({ optimistic: false });
-                    if (complete && currentQueryResult) {
-                        // Run our reducer using the current query result and the mutation result.
-                        const nextQueryResult = updater(currentQueryResult, {
-                            mutationResult: result,
-                            queryName: (document && (0, internal_1.getOperationName)(document)) || void 0,
-                            queryVariables: variables,
-                        });
-                        // Write the modified result back into the store if we got a new result.
-                        if (nextQueryResult) {
-                            cacheWrites.push({
-                                result: nextQueryResult,
-                                dataId: "ROOT_QUERY",
-                                query: document,
-                                variables,
-                            });
-                        }
-                    }
-                });
-            }
-        }
-        if (cacheWrites.length > 0 ||
-            (mutation.refetchQueries || "").length > 0 ||
-            mutation.update ||
-            mutation.onQueryUpdated ||
-            mutation.removeOptimistic) {
-            const results = [];
-            this.refetchQueries({
-                updateCache: (cache) => {
-                    if (!skipCache) {
-                        cacheWrites.forEach((write) => cache.write(write));
-                    }
-                    // If the mutation has some writes associated with it then we need to
-                    // apply those writes to the store by running this reducer again with
-                    // a write action.
-                    const { update } = mutation;
-                    // Determine whether result is a SingleExecutionResult,
-                    // or the final ExecutionPatchResult.
-                    const isFinalResult = !(0, internal_1.isExecutionPatchResult)(result) ||
-                        ((0, internal_1.isExecutionPatchIncrementalResult)(result) && !result.hasNext);
-                    if (update) {
-                        if (!skipCache) {
-                            // Re-read the ROOT_MUTATION data we just wrote into the cache
-                            // (the first cache.write call in the cacheWrites.forEach loop
-                            // above), so field read functions have a chance to run for
-                            // fields within mutation result objects.
-                            const diff = cache.diff({
-                                id: "ROOT_MUTATION",
-                                // The cache complains if passed a mutation where it expects a
-                                // query, so we transform mutations and subscriptions to queries
-                                // (only once, thanks to this.transformCache).
-                                query: this.getDocumentInfo(mutation.document).asQuery,
-                                variables: mutation.variables,
-                                optimistic: false,
-                                returnPartialData: true,
-                            });
-                            if (diff.complete) {
-                                result = { ...result, data: diff.result };
-                                if ("incremental" in result) {
-                                    delete result.incremental;
-                                }
-                                if ("hasNext" in result) {
-                                    delete result.hasNext;
-                                }
-                            }
-                        }
-                        // If we've received the whole response,
-                        // either a SingleExecutionResult or the final ExecutionPatchResult,
-                        // call the update function.
-                        if (isFinalResult) {
-                            update(cache, result, {
-                                context: mutation.context,
-                                variables: mutation.variables,
-                            });
-                        }
-                    }
-                    // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it
-                    // shallow to allow rolling back optimistic evictions.
-                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {
-                        cache.modify({
-                            id: "ROOT_MUTATION",
-                            fields(value, { fieldName, DELETE }) {
-                                return fieldName === "__typename" ? value : DELETE;
-                            },
-                        });
-                    }
-                },
-                include: mutation.refetchQueries,
-                // Write the final mutation.result to the root layer of the cache.
-                optimistic: false,
-                // Remove the corresponding optimistic layer at the same time as we
-                // write the final non-optimistic result.
-                removeOptimistic: mutation.removeOptimistic,
-                // Let the caller of client.mutate optionally determine the refetching
-                // behavior for watched queries after the mutation.update function runs.
-                // If no onQueryUpdated function was provided for this mutation, pass
-                // null instead of undefined to disable the default refetching behavior.
-                onQueryUpdated: mutation.onQueryUpdated || null,
-            }).forEach((result) => results.push(result));
-            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {
-                // Returning a promise here makes the mutation await that promise, so we
-                // include results in that promise's work if awaitRefetchQueries or an
-                // onQueryUpdated function was specified.
-                return Promise.all(results).then(() => result);
-            }
-        }
-        return Promise.resolve(result);
-    }
-    markMutationOptimistic(optimisticResponse, mutation) {
-        const data = typeof optimisticResponse === "function" ?
-            optimisticResponse(mutation.variables, { IGNORE })
-            : optimisticResponse;
-        if (data === IGNORE) {
-            return false;
-        }
-        this.cache.recordOptimisticTransaction((cache) => {
-            try {
-                this.markMutationResult({
-                    ...mutation,
-                    result: { data },
-                }, cache);
-            }
-            catch (error) {
-                __DEV__ && invariant_1.invariant.error(error);
-            }
-        }, mutation.mutationId);
-        return true;
-    }
     fetchQuery(options, networkStatus) {
-        const queryInfo = new QueryInfo_js_1.QueryInfo({
-            queryManager: this,
-        });
-        return (0, rxjs_2.lastValueFrom)(this.fetchObservableWithInfo(queryInfo, options, {
+        return (0, rxjs_2.lastValueFrom)(this.fetchObservableWithInfo(options, {
             networkStatus,
         }).observable.pipe((0, internal_1.filterMap)((value) => {
             switch (value.kind) {
@@ -517,18 +334,10 @@ class QueryManager {
             }),
         }));
     }
-    queryIdCounter = 1;
-    generateQueryId() {
-        return String(this.queryIdCounter++);
-    }
     requestIdCounter = 1;
     generateRequestId() {
         return this.requestIdCounter++;
     }
-    mutationIdCounter = 1;
-    generateMutationId() {
-        return String(this.mutationIdCounter++);
-    }
     clearStore(options = {
         discardWatches: true,
     }) {
@@ -537,7 +346,7 @@ class QueryManager {
         // depend on values that previously existed in the data portion of the
         // store. So, we cancel the promises and observers that we have issued
         // so far and not yet resolved (in the case of queries).
-        this.cancelPendingFetches((0, invariant_1.newInvariantError)(86));
+        this.cancelPendingFetches((0, invariant_1.newInvariantError)(85));
         this.obsQueries.forEach((observableQuery) => {
             // Set loading to true so listeners don't trigger unless they want
             // results with partial data.
@@ -607,10 +416,10 @@ class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant_1.invariant.warn(87, queryName);
+                        __DEV__ && invariant_1.invariant.warn(86, queryName);
                     }
                     else {
-                        __DEV__ && invariant_1.invariant.warn(88);
+                        __DEV__ && invariant_1.invariant.warn(87);
                     }
                 }
             });
@@ -639,7 +448,7 @@ class QueryManager {
         if (environment_1.__DEV__) {
             (0, invariant_1.invariant)(
                 !this.getDocumentInfo(query).hasClientExports || this.localState,
-                89,
+                88,
                 (0, internal_1.getOperationName)(query, "(anonymous)")
             );
         }
@@ -652,21 +461,17 @@ class QueryManager {
             }))
             : (0, rxjs_2.of)(variables)).pipe((0, rxjs_2.mergeMap)((variables) => {
             const { observable, restart: res } = this.getObservableFromLink(query, context, variables, extensions);
+            const queryInfo = new QueryInfo_js_1.QueryInfo(this);
             restart = res;
             return observable.pipe((0, rxjs_2.map)((rawResult) => {
-                if (fetchPolicy !== "no-cache") {
-                    // the subscription interface should handle not sending us results we no longer subscribe to.
-                    // XXX I don't think we ever send in an object with errors, but we might in the future...
-                    if ((0, QueryInfo_js_1.shouldWriteResult)(rawResult, errorPolicy)) {
-                        this.cache.write({
-                            query,
-                            result: rawResult.data,
-                            dataId: "ROOT_SUBSCRIPTION",
-                            variables: variables,
-                        });
-                    }
-                    this.broadcastQueries();
-                }
+                queryInfo.markSubscriptionResult(rawResult, {
+                    document: query,
+                    variables,
+                    errorPolicy,
+                    cacheWriteBehavior: fetchPolicy === "no-cache" ?
+                        0 /* CacheWriteBehavior.FORBID */
+                        : 2 /* CacheWriteBehavior.MERGE */,
+                });
                 const result = {
                     data: rawResult.data ?? undefined,
                 };
@@ -782,7 +587,7 @@ class QueryManager {
                 const { operation } = (0, internal_1.getOperationDefinition)(query);
                 (0, invariant_1.invariant)(
                     this.localState,
-                    90,
+                    89,
                     operation[0].toUpperCase() + operation.slice(1),
                     operationName ?? "(anonymous)"
                 );
@@ -806,7 +611,7 @@ class QueryManager {
             })),
         };
     }
-    getResultsFromLink(queryInfo, cacheWriteBehavior, options) {
+    getResultsFromLink(options, { queryInfo, cacheWriteBehavior, observableQuery, }) {
         const requestId = (queryInfo.lastRequestId = this.generateRequestId());
         const { errorPolicy } = options;
         // Performing transformForLink here gives this.cache a chance to fill in
@@ -821,26 +626,35 @@ class QueryManager {
             if (requestId >= queryInfo.lastRequestId) {
                 if (hasErrors && errorPolicy === "none") {
                     queryInfo.resetLastWrite();
-                    queryInfo.observableQuery?.["resetNotifications"]();
+                    observableQuery?.["resetNotifications"]();
                     // Throwing here effectively calls observer.error.
                     throw new errors_1.CombinedGraphQLErrors(result);
                 }
                 // Use linkDocument rather than queryInfo.document so the
                 // operation/fragments used to write the result are the same as the
                 // ones used to obtain it from the link.
-                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);
+                queryInfo.markQueryResult(result, {
+                    ...options,
+                    document: linkDocument,
+                    cacheWriteBehavior,
+                });
             }
             const aqr = {
                 data: result.data,
-                dataState: result.data ? "complete" : "empty",
-                loading: false,
-                networkStatus: networkStatus_js_1.NetworkStatus.ready,
-                partial: !result.data,
+                ...((0, internal_1.isExecutionPatchResult)(result) && result.hasNext ?
+                    {
+                        loading: true,
+                        networkStatus: networkStatus_js_1.NetworkStatus.streaming,
+                        dataState: "streaming",
+                        partial: true,
+                    }
+                    : {
+                        dataState: result.data ? "complete" : "empty",
+                        loading: false,
+                        networkStatus: networkStatus_js_1.NetworkStatus.ready,
+                        partial: !result.data,
+                    }),
             };
-            if ((0, internal_1.isExecutionPatchResult)(result) && result.hasNext) {
-                aqr.dataState = "streaming";
-                aqr.partial = true;
-            }
             // In the case we start multiple network requests simulatenously, we
             // want to ensure we properly set `data` if we're reporting on an old
             // result which will not be caught by the conditional above that ends up
@@ -861,7 +675,7 @@ class QueryManager {
             // Avoid storing errors from older interrupted queries.
             if (requestId >= queryInfo.lastRequestId && errorPolicy === "none") {
                 queryInfo.resetLastWrite();
-                queryInfo.observableQuery?.["resetNotifications"]();
+                observableQuery?.["resetNotifications"]();
                 throw error;
             }
             const aqr = {
@@ -878,11 +692,11 @@ class QueryManager {
             return (0, rxjs_2.of)(aqr);
         }));
     }
-    fetchObservableWithInfo(queryInfo, options, { 
+    fetchObservableWithInfo(options, { 
     // The initial networkStatus for this fetch, most often
     // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
     // or setVariables.
-    networkStatus = networkStatus_js_1.NetworkStatus.loading, query = options.query, fetchQueryOperator = (x) => x, onCacheHit = () => { }, }) {
+    networkStatus = networkStatus_js_1.NetworkStatus.loading, query = options.query, fetchQueryOperator = (x) => x, onCacheHit = () => { }, observableQuery, }) {
         const variables = this.getVariables(query, options.variables);
         const defaults = this.defaultOptions.watchQuery;
         let { fetchPolicy = (defaults && defaults.fetchPolicy) || "cache-first", errorPolicy = (defaults && defaults.errorPolicy) || "none", returnPartialData = false, notifyOnNetworkStatusChange = true, context = {}, } = options;
@@ -899,6 +713,7 @@ class QueryManager {
             notifyOnNetworkStatusChange,
             context,
         });
+        const queryInfo = new QueryInfo_js_1.QueryInfo(this, observableQuery);
         const fromVariables = (variables) => {
             // Since normalized is always a fresh copy of options, it's safe to
             // modify its properties here, rather than creating yet another new
@@ -911,24 +726,23 @@ class QueryManager {
                     normalized.refetchWritePolicy !== "merge") ?
                     1 /* CacheWriteBehavior.OVERWRITE */
                     : 2 /* CacheWriteBehavior.MERGE */;
-            const observableWithInfo = this.fetchQueryByPolicy(queryInfo, normalized, cacheWriteBehavior, onCacheHit);
+            const observableWithInfo = this.fetchQueryByPolicy(normalized, { queryInfo, cacheWriteBehavior, onCacheHit, observableQuery });
             observableWithInfo.observable =
                 observableWithInfo.observable.pipe(fetchQueryOperator);
             if (
             // If we're in standby, postpone advancing options.fetchPolicy using
             // applyNextFetchPolicy.
-            normalized.fetchPolicy !== "standby" &&
-                queryInfo.observableQuery) {
-                queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
+            normalized.fetchPolicy !== "standby") {
+                observableQuery?.["applyNextFetchPolicy"]("after-fetch", options);
             }
             return observableWithInfo;
         };
         // This cancel function needs to be set before the concast is created,
         // in case concast creation synchronously cancels the request.
         const cleanupCancelFn = () => {
-            this.fetchCancelFns.delete(queryInfo.queryId);
+            this.fetchCancelFns.delete(queryInfo.id);
         };
-        this.fetchCancelFns.set(queryInfo.queryId, (error) => {
+        this.fetchCancelFns.set(queryInfo.id, (error) => {
             fetchCancelSubject.next({
                 kind: "E",
                 error,
@@ -948,7 +762,7 @@ class QueryManager {
             if (environment_1.__DEV__) {
                 (0, invariant_1.invariant)(
                     this.localState,
-                    91,
+                    90,
                     (0, internal_1.getOperationName)(normalized.query, "(anonymous)")
                 );
             }
@@ -1120,7 +934,7 @@ class QueryManager {
                 !this.noCacheWarningsByCause.has(cause)) {
                 this.noCacheWarningsByCause.add(cause);
                 __DEV__ && invariant_1.invariant.warn(
-                    92,
+                    91,
                     (0, internal_1.getOperationName)(document, `Unnamed ${operationType ?? "operation"}`)
                 );
             }
@@ -1135,12 +949,13 @@ class QueryManager {
             (0, masking_1.maskFragment)(data, fragment, this.cache, fragmentName)
             : data;
     }
-    fetchQueryByPolicy(queryInfo, { query, variables, fetchPolicy, errorPolicy, returnPartialData, context, }, cacheWriteBehavior, onCacheHit) {
-        queryInfo.init({
-            document: query,
+    fetchQueryByPolicy({ query, variables, fetchPolicy, errorPolicy, returnPartialData, context, }, { cacheWriteBehavior, onCacheHit, queryInfo, observableQuery, }) {
+        const readCache = () => this.cache.diff({
+            query,
             variables,
+            returnPartialData: true,
+            optimistic: true,
         });
-        const readCache = () => this.cache.diff(queryInfo.getDiffOptions());
         const resultsFromCache = (diff, networkStatus) => {
             const data = diff.result;
             if (environment_1.__DEV__ && !returnPartialData && data !== null) {
@@ -1181,7 +996,7 @@ class QueryManager {
                 if (environment_1.__DEV__) {
                     (0, invariant_1.invariant)(
                         this.localState,
-                        93,
+                        92,
                         (0, internal_1.getOperationName)(query, "(anonymous)")
                     );
                 }
@@ -1211,12 +1026,16 @@ class QueryManager {
             }
             return fromData(data || undefined);
         };
-        const resultsFromLink = () => this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
+        const resultsFromLink = () => this.getResultsFromLink({
             query,
             variables,
             context,
             fetchPolicy,
             errorPolicy,
+        }, {
+            cacheWriteBehavior,
+            queryInfo,
+            observableQuery,
         }).pipe(validateDidEmitValue(), (0, rxjs_2.materialize)(), (0, rxjs_2.map)((result) => ({
             ...result,
             source: "network",
@@ -1271,7 +1090,7 @@ function validateDidEmitValue() {
             didEmitValue = true;
         },
         complete() {
-            (0, invariant_1.invariant)(didEmitValue, 94);
+            (0, invariant_1.invariant)(didEmitValue, 93);
         },
     });
 }