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

package/core/QueryManager.js

@@ -1,11 +1,12 @@
 import { Trie } from "@wry/trie";
+import { OperationTypeNode } from "graphql";
 import { catchError, concat, EMPTY, filter, from, lastValueFrom, map, mergeMap, mergeWith, Observable, of, share, shareReplay, Subject, tap, } from "rxjs";
 import { canonicalStringify } from "@apollo/client/cache";
-import { CombinedGraphQLErrors, graphQLResultHasProtocolErrors, UnconventionalError, } from "@apollo/client/errors";
+import { CombinedGraphQLErrors, graphQLResultHasProtocolErrors, toErrorLike, } from "@apollo/client/errors";
 import { PROTOCOL_ERRORS_SYMBOL } from "@apollo/client/errors";
 import { execute } from "@apollo/client/link/core";
 import { maskFragment, maskOperation } from "@apollo/client/masking";
-import { print } from "@apollo/client/utilities";
+import { checkDocument, print } from "@apollo/client/utilities";
 import { AutoCleanedWeakCache, cacheSizes } from "@apollo/client/utilities";
 import { addNonReactiveToNamedFragments, hasDirectives, isExecutionPatchIncrementalResult, isExecutionPatchResult, isFullyUnmaskedOperation, removeDirectivesFromDocument, } from "@apollo/client/utilities";
 import { DocumentTransform, getDefaultValues, getGraphQLErrorsFromResult, getOperationDefinition, getOperationName, graphQLResultHasError, hasClientExports, isDocumentNode, isNonEmptyArray, isNonNullObject, makeUniqueId, } from "@apollo/client/utilities";
@@ -88,15 +89,16 @@ export class QueryManager {
         this.queries.forEach((_info, queryId) => {
             this.removeQuery(queryId);
         });
-        this.cancelPendingFetches(newInvariantError(74));
+        this.cancelPendingFetches(newInvariantError(72));
     }
     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, }) {
-        invariant(mutation, 75);
-        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 76);
+        invariant(mutation, 73);
+        checkDocument(mutation, OperationTypeNode.MUTATION);
+        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 74);
         const mutationId = this.generateMutationId();
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
@@ -189,7 +191,7 @@ export class QueryManager {
                     }
                 },
                 error: (err) => {
-                    const error = maybeWrapError(err);
+                    const error = toErrorLike(err);
                     if (mutationStoreValue) {
                         mutationStoreValue.loading = false;
                         mutationStoreValue.error = error;
@@ -394,7 +396,7 @@ export class QueryManager {
         return true;
     }
     fetchQuery(queryId, options, networkStatus) {
-        return lastValueFrom(this.fetchObservableWithInfo(queryId, options, networkStatus).observable.pipe(map(toQueryResult)), {
+        return lastValueFrom(this.fetchObservableWithInfo(this.getOrCreateQuery(queryId), options, networkStatus).observable.pipe(map(toQueryResult)), {
             // This default is needed when a `standby` fetch policy is used to avoid
             // an EmptyError from rejecting this promise.
             defaultValue: { data: undefined },
@@ -450,6 +452,7 @@ export class QueryManager {
         };
     }
     watchQuery(options) {
+        checkDocument(options.query, OperationTypeNode.QUERY);
         const query = this.transform(options.query);
         // assign variable default values if supplied
         // NOTE: We don't modify options.query here with the transformed query to
@@ -468,17 +471,17 @@ export class QueryManager {
             options,
         });
         observable["lastQuery"] = query;
-        this.queries.set(observable.queryId, queryInfo);
+        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,
-            observableQuery: observable,
-            variables: observable.variables,
-        });
+        queryInfo.init({ document: query, variables: observable.variables });
+        queryInfo.setObservableQuery(observable);
         return observable;
     }
     query(options, queryId = this.generateQueryId()) {
+        checkDocument(options.query, OperationTypeNode.QUERY);
         const query = this.transform(options.query);
         return this.fetchQuery(queryId, { ...options, query })
             .then((value) => ({
@@ -512,7 +515,7 @@ export 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(newInvariantError(77));
+        this.cancelPendingFetches(newInvariantError(75));
         this.queries.forEach((queryInfo) => {
             if (queryInfo.observableQuery) {
                 // Set loading to true so listeners don't trigger unless they want
@@ -578,7 +581,7 @@ export class QueryManager {
                 // 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.getQuery(queryId).init({
+                const queryInfo = this.getOrCreateQuery(queryId).init({
                     document: options.query,
                     variables: options.variables,
                 });
@@ -600,10 +603,10 @@ export class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant.warn(78, queryName);
+                        __DEV__ && invariant.warn(76, queryName);
                     }
                     else {
-                        __DEV__ && invariant.warn(79);
+                        __DEV__ && invariant.warn(77);
                     }
                 }
             });
@@ -619,17 +622,15 @@ export class QueryManager {
                 (fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
                 observableQueryPromises.push(observableQuery.refetch());
             }
-            this.getQuery(queryId).setDiff(null);
+            (this.queries.get(queryId) || observableQuery["queryInfo"]).setDiff(null);
         });
         this.broadcastQueries();
         return Promise.all(observableQueryPromises);
     }
-    setObservableQuery(observableQuery) {
-        this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);
-    }
     startGraphQLSubscription(options) {
         let { query, variables } = options;
         const { fetchPolicy, errorPolicy = "none", context = {}, extensions = {}, } = options;
+        checkDocument(query, OperationTypeNode.SUBSCRIPTION);
         query = this.transform(query);
         variables = this.getVariables(query, variables);
         const makeObservable = (variables) => this.getObservableFromLink(query, context, variables, extensions).pipe(map((rawResult) => {
@@ -672,7 +673,7 @@ export class QueryManager {
             if (errorPolicy === "ignore") {
                 return of({ data: undefined });
             }
-            return of({ data: undefined, error: maybeWrapError(error) });
+            return of({ data: undefined, error: toErrorLike(error) });
         }), filter((result) => !!(result.data || result.error)));
         if (this.getDocumentInfo(query).hasClientExports) {
             const observablePromise = this.localState
@@ -698,14 +699,14 @@ export class QueryManager {
         // The same queryId could have two rejection fns for two promises
         this.fetchCancelFns.delete(queryId);
         if (this.queries.has(queryId)) {
-            this.getQuery(queryId).stop();
+            this.queries.get(queryId)?.stop();
             this.queries.delete(queryId);
         }
     }
     broadcastQueries() {
         if (this.onBroadcast)
             this.onBroadcast();
-        this.queries.forEach((info) => info.notify());
+        this.queries.forEach((info) => info.observableQuery?.["notify"]());
     }
     getLocalState() {
         return this.localState;
@@ -784,7 +785,7 @@ export class QueryManager {
             if (requestId >= queryInfo.lastRequestId) {
                 if (hasErrors && errorPolicy === "none") {
                     queryInfo.resetLastWrite();
-                    queryInfo.reset();
+                    queryInfo.observableQuery?.["resetNotifications"]();
                     // Throwing here effectively calls observer.error.
                     throw new CombinedGraphQLErrors(result);
                 }
@@ -812,11 +813,11 @@ export class QueryManager {
             }
             return aqr;
         }), catchError((error) => {
-            error = maybeWrapError(error);
+            error = toErrorLike(error);
             // Avoid storing errors from older interrupted queries.
             if (requestId >= queryInfo.lastRequestId && errorPolicy === "none") {
                 queryInfo.resetLastWrite();
-                queryInfo.reset();
+                queryInfo.observableQuery?.["resetNotifications"]();
                 throw error;
             }
             const aqr = {
@@ -832,13 +833,12 @@ export class QueryManager {
             return of(aqr);
         }));
     }
-    fetchObservableWithInfo(queryId, options, 
+    fetchObservableWithInfo(queryInfo, options, 
     // The initial networkStatus for this fetch, most often
     // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
     // or setVariables.
     networkStatus = NetworkStatus.loading, query = options.query, emitLoadingState = false) {
         const variables = this.getVariables(query, options.variables);
-        const queryInfo = this.getQuery(queryId);
         const defaults = this.defaultOptions.watchQuery;
         let { fetchPolicy = (defaults && defaults.fetchPolicy) || "cache-first", errorPolicy = (defaults && defaults.errorPolicy) || "none", returnPartialData = false, notifyOnNetworkStatusChange = false, context = {}, } = options;
         if (this.prioritizeCacheValues &&
@@ -872,13 +872,13 @@ export class QueryManager {
         // 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(queryId);
+            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(queryId, (reason) => {
+        this.fetchCancelFns.set(queryInfo.queryId, (reason) => {
             fetchCancelSubject.error(reason);
             cleanupCancelFn();
         });
@@ -916,7 +916,7 @@ export class QueryManager {
             this.getObservableQueries(include).forEach((oq, queryId) => {
                 includedQueriesById.set(queryId, {
                     oq,
-                    lastDiff: this.getQuery(queryId).getDiff(),
+                    lastDiff: (this.queries.get(queryId) || oq["queryInfo"]).getDiff(),
                 });
             });
         }
@@ -1002,9 +1002,7 @@ export class QueryManager {
                 // queries, even the QueryOptions ones.
                 if (onQueryUpdated) {
                     if (!diff) {
-                        const info = oq["queryInfo"];
-                        info.reset(); // Force info.getDiff() to read from cache.
-                        diff = info.getDiff();
+                        diff = this.cache.diff(oq["queryInfo"]["getDiffOptions"]());
                     }
                     result = onQueryUpdated(oq, diff, lastDiff);
                 }
@@ -1044,7 +1042,7 @@ export class QueryManager {
                 !isFullyUnmaskedOperation(document) &&
                 !this.noCacheWarningsByQueryId.has(operationId)) {
                 this.noCacheWarningsByQueryId.add(operationId);
-                __DEV__ && invariant.warn(80, getOperationName(document) ??
+                __DEV__ && invariant.warn(78, getOperationName(document) ??
                     `Unnamed ${operationType ?? "operation"}`);
             }
         }
@@ -1191,7 +1189,7 @@ export class QueryManager {
                 return { fromLink: false, observable: EMPTY };
         }
     }
-    getQuery(queryId) {
+    getOrCreateQuery(queryId) {
         if (queryId && !this.queries.has(queryId)) {
             this.queries.set(queryId, new QueryInfo(this, queryId));
         }
@@ -1206,23 +1204,6 @@ export class QueryManager {
         };
     }
 }
-function isErrorLike(error) {
-    return (error !== null &&
-        typeof error === "object" &&
-        typeof error.message === "string" &&
-        typeof error.name === "string" &&
-        (typeof error.stack === "undefined" ||
-            typeof error.stack === "string"));
-}
-function maybeWrapError(error) {
-    if (isErrorLike(error)) {
-        return error;
-    }
-    if (typeof error === "string") {
-        return new Error(error, { cause: error });
-    }
-    return new UnconventionalError(error);
-}
 function validateDidEmitValue() {
     let didEmitValue = false;
     return tap({
@@ -1230,7 +1211,7 @@ function validateDidEmitValue() {
             didEmitValue = true;
         },
         complete() {
-            invariant(didEmitValue, 81);
+            invariant(didEmitValue, 79);
         },
     });
 }