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

package/core/QueryManager.js

@@ -1,7 +1,7 @@
 import { Trie } from "@wry/trie";
 import { BREAK, Kind, OperationTypeNode, visit } from "graphql";
 import { Observable } from "rxjs";
-import { catchError, concat, EMPTY, filter, finalize, from, lastValueFrom, map, materialize, mergeMap, mergeWith, of, share, shareReplay, Subject, tap, } from "rxjs";
+import { catchError, concat, EMPTY, filter, finalize, from, lastValueFrom, map, materialize, mergeMap, of, share, shareReplay, Subject, tap, } from "rxjs";
 import { canonicalStringify } from "@apollo/client/cache";
 import { CombinedGraphQLErrors, graphQLResultHasProtocolErrors, registerLinkError, toErrorLike, } from "@apollo/client/errors";
 import { PROTOCOL_ERRORS_SYMBOL } from "@apollo/client/errors";
@@ -40,9 +40,10 @@ export class QueryManager {
     prioritizeCacheValues = false;
     onBroadcast;
     mutationStore;
-    // All the queries that the QueryManager is currently managing (not
-    // including mutations and subscriptions).
-    queries = new Map();
+    /**
+     * All ObservableQueries that currently have at least one subscriber.
+     */
+    obsQueries = new Set();
     // Maps from queryId strings to Promise rejection functions for
     // currently active queries and fetches.
     // Use protected instead of private field so
@@ -87,9 +88,7 @@ export class QueryManager {
      * to dispose of this QueryManager instance.
      */
     stop() {
-        this.queries.forEach((_info, queryId) => {
-            this.removeQuery(queryId);
-        });
+        this.obsQueries.forEach((oq) => oq.stop());
         this.cancelPendingFetches(newInvariantError(82));
     }
     cancelPendingFetches(error) {
@@ -136,6 +135,7 @@ export class QueryManager {
             });
         this.broadcastQueries();
         return new Promise((resolve, reject) => {
+            const cause = {};
             return this.getObservableFromLink(mutation, {
                 ...context,
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
@@ -187,7 +187,7 @@ export class QueryManager {
                                 document: mutation,
                                 data: storeResult.data,
                                 fetchPolicy,
-                                id: mutationId,
+                                cause,
                             }),
                         };
                         if (graphQLResultHasError(storeResult)) {
@@ -262,20 +262,15 @@ export class QueryManager {
             }
             const { updateQueries } = mutation;
             if (updateQueries) {
-                this.queries.forEach(({ observableQuery }, queryId) => {
+                this.obsQueries.forEach((observableQuery) => {
                     const queryName = observableQuery && observableQuery.queryName;
                     if (!queryName || !hasOwnProperty.call(updateQueries, queryName)) {
                         return;
                     }
                     const updater = updateQueries[queryName];
-                    const { document, variables } = this.queries.get(queryId);
+                    const { query: document, variables } = observableQuery;
                     // Read the current query result from the store.
-                    const { result: currentQueryResult, complete } = cache.diff({
-                        query: document,
-                        variables,
-                        returnPartialData: true,
-                        optimistic: false,
-                    });
+                    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, {
@@ -403,8 +398,11 @@ export class QueryManager {
         }, mutation.mutationId);
         return true;
     }
-    fetchQuery(queryId, options, networkStatus) {
-        return lastValueFrom(this.fetchObservableWithInfo(this.getOrCreateQuery(queryId), options, {
+    fetchQuery(options, networkStatus) {
+        const queryInfo = new QueryInfo({
+            queryManager: this,
+        });
+        return lastValueFrom(this.fetchObservableWithInfo(queryInfo, options, {
             networkStatus,
         }).observable.pipe(filterMap((value) => {
             switch (value.kind) {
@@ -487,38 +485,26 @@ export class QueryManager {
         if (typeof options.notifyOnNetworkStatusChange === "undefined") {
             options.notifyOnNetworkStatusChange = true;
         }
-        const queryInfo = new QueryInfo(this);
         const observable = new ObservableQuery({
             queryManager: this,
-            queryInfo,
             options,
+            transformedQuery: query,
         });
-        observable["lastQuery"] = query;
-        if (!ObservableQuery["inactiveOnCreation"].getValue()) {
-            this.queries.set(observable.queryId, queryInfo);
-        }
-        // We give queryInfo the transformed query to ensure the first cache diff
-        // uses the transformed query instead of the raw query
-        queryInfo.init({ document: query, variables: observable.variables });
-        queryInfo.setObservableQuery(observable);
         return observable;
     }
-    async query(options, queryId = this.generateQueryId()) {
+    async query(options) {
         const query = this.transform(options.query);
-        return this.fetchQuery(queryId, {
+        return this.fetchQuery({
             ...options,
             query,
-        })
-            .then((value) => ({
+        }).then((value) => ({
             ...value,
             data: this.maskOperation({
                 document: query,
                 data: value?.data,
                 fetchPolicy: options.fetchPolicy,
-                id: queryId,
             }),
-        }))
-            .finally(() => this.removeQuery(queryId));
+        }));
     }
     queryIdCounter = 1;
     generateQueryId() {
@@ -541,10 +527,10 @@ export class QueryManager {
         // 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(newInvariantError(86));
-        this.queries.forEach(({ observableQuery }) => {
+        this.obsQueries.forEach((observableQuery) => {
             // Set loading to true so listeners don't trigger unless they want
             // results with partial data.
-            observableQuery?.reset();
+            observableQuery.reset();
         });
         if (this.mutationStore) {
             this.mutationStore = {};
@@ -553,7 +539,7 @@ export class QueryManager {
         return this.cache.reset(options);
     }
     getObservableQueries(include = "active") {
-        const queries = new Map();
+        const queries = new Set();
         const queryNames = new Map();
         const queryNamesAndQueryStrings = new Map();
         const legacyQueryOptions = new Set();
@@ -573,49 +559,36 @@ export class QueryManager {
                 }
             });
         }
-        this.queries.forEach(({ observableQuery: oq, document }, queryId) => {
-            if (oq) {
-                if (include === "all") {
-                    queries.set(queryId, oq);
-                    return;
-                }
-                const { queryName, options: { fetchPolicy }, } = oq;
-                if (fetchPolicy === "standby" ||
-                    (include === "active" && !oq.hasObservers())) {
-                    return;
-                }
-                if (include === "active" ||
-                    (queryName && queryNamesAndQueryStrings.has(queryName)) ||
-                    (document && queryNamesAndQueryStrings.has(print(document)))) {
-                    queries.set(queryId, oq);
-                    if (queryName)
-                        queryNamesAndQueryStrings.set(queryName, true);
-                    if (document)
-                        queryNamesAndQueryStrings.set(print(document), true);
-                }
+        this.obsQueries.forEach((oq) => {
+            const document = print(this.transform(oq.options.query));
+            if (include === "all") {
+                queries.add(oq);
+                return;
+            }
+            const { queryName, options: { fetchPolicy }, } = oq;
+            if (include === "active" && fetchPolicy === "standby") {
+                return;
+            }
+            if (include === "active" ||
+                (queryName && queryNamesAndQueryStrings.has(queryName)) ||
+                (document && queryNamesAndQueryStrings.has(document))) {
+                queries.add(oq);
+                if (queryName)
+                    queryNamesAndQueryStrings.set(queryName, true);
+                if (document)
+                    queryNamesAndQueryStrings.set(document, true);
             }
         });
         if (legacyQueryOptions.size) {
             legacyQueryOptions.forEach((options) => {
-                // We will be issuing a fresh network request for this query, so we
-                // pre-allocate a new query ID here, using a special prefix to enable
-                // cleaning up these temporary queries later, after fetching.
-                const queryId = makeUniqueId("legacyOneTimeQuery");
-                const queryInfo = this.getOrCreateQuery(queryId).init({
-                    document: options.query,
-                    variables: options.variables,
-                });
                 const oq = new ObservableQuery({
                     queryManager: this,
-                    queryInfo,
                     options: {
                         ...options,
                         fetchPolicy: "network-only",
                     },
                 });
-                invariant(oq.queryId === queryId);
-                queryInfo.setObservableQuery(oq);
-                queries.set(queryId, oq);
+                queries.add(oq);
             });
         }
         if (__DEV__ && queryNamesAndQueryStrings.size) {
@@ -635,13 +608,12 @@ export class QueryManager {
     }
     refetchObservableQueries(includeStandby = false) {
         const observableQueryPromises = [];
-        this.getObservableQueries(includeStandby ? "all" : "active").forEach((observableQuery, queryId) => {
+        this.getObservableQueries(includeStandby ? "all" : "active").forEach((observableQuery) => {
             const { fetchPolicy } = observableQuery.options;
             if (includeStandby ||
                 (fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
                 observableQueryPromises.push(observableQuery.refetch());
             }
-            (this.queries.get(queryId) || observableQuery["queryInfo"]).resetDiff();
         });
         this.broadcastQueries();
         return Promise.all(observableQueryPromises);
@@ -715,27 +687,10 @@ export class QueryManager {
         }));
         return Object.assign(observable, { restart: () => restart?.() });
     }
-    removeQuery(queryId) {
-        // teardown all links
-        // Both `QueryManager.fetchRequest` and `QueryManager.query` create separate promises
-        // that each add their reject functions to fetchCancelFns.
-        // A query created with `QueryManager.query()` could trigger a `QueryManager.fetchRequest`.
-        // The same queryId could have two rejection fns for two promises
-        this.fetchCancelFns.delete(queryId);
-        if (this.queries.has(queryId)) {
-            const oq = this.queries.get(queryId).observableQuery;
-            if (oq) {
-                oq["resetNotifications"]();
-                oq["unsubscribeFromCache"]?.();
-                oq.stopPolling();
-            }
-            this.queries.delete(queryId);
-        }
-    }
     broadcastQueries() {
         if (this.onBroadcast)
             this.onBroadcast();
-        this.queries.forEach((info) => info.observableQuery?.notify());
+        this.obsQueries.forEach((observableQuery) => observableQuery.notify());
     }
     // Use protected instead of private field so
     // @apollo/experimental-nextjs-app-support can access type info.
@@ -961,10 +916,6 @@ export class QueryManager {
         // in case concast creation synchronously cancels the request.
         const cleanupCancelFn = () => {
             this.fetchCancelFns.delete(queryInfo.queryId);
-            // We need to call `complete` on the subject here otherwise the merged
-            // observable will never complete since it waits for all source
-            // observables to complete before itself completes.
-            fetchCancelSubject.complete();
         };
         this.fetchCancelFns.set(queryInfo.queryId, (error) => {
             fetchCancelSubject.next({
@@ -972,8 +923,6 @@ export class QueryManager {
                 error,
                 source: "network",
             });
-            fetchCancelSubject.complete();
-            cleanupCancelFn();
         });
         const fetchCancelSubject = new Subject();
         let observable, containsDataFromLink;
@@ -1007,16 +956,22 @@ export class QueryManager {
             observable = sourcesWithInfo.observable;
         }
         return {
-            observable: observable.pipe(tap({ error: cleanupCancelFn, complete: cleanupCancelFn }), mergeWith(fetchCancelSubject), share()),
+            // Merge `observable` with `fetchCancelSubject`, in a way that completing or
+            // erroring either of them will complete the merged obserable.
+            observable: new Observable((observer) => {
+                observer.add(cleanupCancelFn);
+                observable.subscribe(observer);
+                fetchCancelSubject.subscribe(observer);
+            }).pipe(share()),
             fromLink: containsDataFromLink,
         };
     }
     refetchQueries({ updateCache, include, optimistic = false, removeOptimistic = optimistic ? makeUniqueId("refetchQueries") : void 0, onQueryUpdated, }) {
-        const includedQueriesById = new Map();
+        const includedQueriesByOq = new Map();
         if (include) {
-            this.getObservableQueries(include).forEach((oq, queryId) => {
+            this.getObservableQueries(include).forEach((oq) => {
                 const current = oq.getCurrentResult();
-                includedQueriesById.set(queryId, {
+                includedQueriesByOq.set(oq, {
                     oq,
                     lastDiff: {
                         result: current?.data,
@@ -1070,13 +1025,13 @@ export class QueryManager {
                 removeOptimistic,
                 onWatchUpdated(watch, diff, lastDiff) {
                     const oq = watch.watcher;
-                    if (oq instanceof ObservableQuery) {
-                        if (onQueryUpdated && !handled.has(oq)) {
-                            handled.add(oq);
+                    if (oq instanceof ObservableQuery && !handled.has(oq)) {
+                        handled.add(oq);
+                        if (onQueryUpdated) {
                             // Since we're about to handle this query now, remove it from
                             // includedQueriesById, in case it was added earlier because of
                             // options.include.
-                            includedQueriesById.delete(oq.queryId);
+                            includedQueriesByOq.delete(oq);
                             let result = onQueryUpdated(oq, diff, lastDiff);
                             if (result === true) {
                                 // The onQueryUpdated function requested the default refetching
@@ -1098,20 +1053,20 @@ export class QueryManager {
                             // If we don't have an onQueryUpdated function, and onQueryUpdated
                             // was not disabled by passing null, make sure this query is
                             // "included" like any other options.include-specified query.
-                            includedQueriesById.set(oq.queryId, { oq, lastDiff, diff });
+                            includedQueriesByOq.set(oq, { oq, lastDiff, diff });
                         }
                     }
                 },
             });
         }
-        if (includedQueriesById.size) {
-            includedQueriesById.forEach(({ oq, lastDiff, diff }, queryId) => {
+        if (includedQueriesByOq.size) {
+            includedQueriesByOq.forEach(({ oq, lastDiff, diff }) => {
                 let result;
                 // If onQueryUpdated is provided, we want to use it for all included
                 // queries, even the QueryOptions ones.
                 if (onQueryUpdated) {
                     if (!diff) {
-                        diff = this.cache.diff(oq["queryInfo"].getDiffOptions());
+                        diff = oq.getCacheDiff();
                     }
                     result = onQueryUpdated(oq, diff, lastDiff);
                 }
@@ -1124,9 +1079,6 @@ export class QueryManager {
                 if (result !== false) {
                     results.set(oq, result);
                 }
-                if (queryId.indexOf("legacyOneTimeQuery") >= 0) {
-                    this.removeQuery(queryId);
-                }
             });
         }
         if (removeOptimistic) {
@@ -1141,18 +1093,17 @@ export class QueryManager {
         }
         return results;
     }
-    noCacheWarningsByQueryId = new Set();
+    noCacheWarningsByCause = new WeakSet();
     maskOperation(options) {
         const { document, data } = options;
         if (__DEV__) {
-            const { fetchPolicy, id } = options;
+            const { fetchPolicy, cause = {} } = options;
             const operationType = getOperationDefinition(document)?.operation;
-            const operationId = (operationType?.[0] ?? "o") + id;
             if (this.dataMasking &&
                 fetchPolicy === "no-cache" &&
                 !isFullyUnmaskedOperation(document) &&
-                !this.noCacheWarningsByQueryId.has(operationId)) {
-                this.noCacheWarningsByQueryId.add(operationId);
+                !this.noCacheWarningsByCause.has(cause)) {
+                this.noCacheWarningsByCause.add(cause);
                 __DEV__ && invariant.warn(92, getOperationName(document, `Unnamed ${operationType ?? "operation"}`));
             }
         }
@@ -1289,12 +1240,6 @@ export class QueryManager {
                 return { fromLink: false, observable: EMPTY };
         }
     }
-    getOrCreateQuery(queryId) {
-        if (queryId && !this.queries.has(queryId)) {
-            this.queries.set(queryId, new QueryInfo(this, queryId));
-        }
-        return this.queries.get(queryId);
-    }
 }
 function validateDidEmitValue() {
     let didEmitValue = false;