@apollo/client 4.0.0-alpha.1 → 4.0.0-alpha.11

package/core/QueryManager.js

@@ -1,17 +1,18 @@
 import { Trie } from "@wry/trie";
-import { catchError, concat, EMPTY, from, lastValueFrom, map, mergeMap, mergeWith, Observable, of, share, shareReplay, Subject, tap, } from "rxjs";
+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, registerLinkError, 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";
 import { mergeIncrementalData } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { onAnyEvent } from "@apollo/client/utilities/internal";
+import { onAnyEvent, toQueryResult } from "@apollo/client/utilities/internal";
 import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
 import { isNetworkRequestInFlight, NetworkStatus } from "./networkStatus.js";
 import { logMissingFieldErrors, ObservableQuery } from "./ObservableQuery.js";
@@ -19,9 +20,8 @@ import { QueryInfo, shouldWriteResult, } from "./QueryInfo.js";
 const { hasOwnProperty } = Object.prototype;
 const IGNORE = {};
 export class QueryManager {
-    cache;
-    link;
     defaultOptions;
+    client;
     assumeImmutableResults;
     documentTransform;
     ssrMode;
@@ -30,6 +30,17 @@ export class QueryManager {
     queryDeduplication;
     clientAwareness = {};
     localState;
+    /**
+     * Whether to prioritize cache values over network results when
+     * `fetchObservableWithInfo` is called.
+     * This will essentially turn a `"network-only"` or `"cache-and-network"`
+     * fetchPolicy into a `"cache-first"` fetchPolicy, but without influencing
+     * the `fetchPolicy` of the `ObservableQuery`.
+     *
+     * This can e.g. be used to prioritize the cache during the first render after
+     * SSR.
+     */
+    prioritizeCacheValues = false;
     onBroadcast;
     mutationStore;
     // All the queries that the QueryManager is currently managing (not
@@ -44,8 +55,7 @@ export class QueryManager {
         const defaultDocumentTransform = new DocumentTransform((document) => this.cache.transformDocument(document), 
         // Allow the apollo cache to manage its own transform caches
         { cache: false });
-        this.cache = options.cache;
-        this.link = options.link;
+        this.client = options.client;
         this.defaultOptions = options.defaultOptions;
         this.queryDeduplication = options.queryDeduplication;
         this.clientAwareness = options.clientAwareness;
@@ -69,6 +79,12 @@ export class QueryManager {
             this.mutationStore = {};
         }
     }
+    get link() {
+        return this.client.link;
+    }
+    get cache() {
+        return this.client.cache;
+    }
     /**
      * Call this method to terminate any active query processes, making it safe
      * to dispose of this QueryManager instance.
@@ -77,15 +93,16 @@ export class QueryManager {
         this.queries.forEach((_info, queryId) => {
             this.removeQuery(queryId);
         });
-        this.cancelPendingFetches(newInvariantError(72));
+        this.cancelPendingFetches(newInvariantError(74));
     }
     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, 73);
-        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 74);
+        invariant(mutation, 75);
+        checkDocument(mutation, OperationTypeNode.MUTATION);
+        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 76);
         const mutationId = this.generateMutationId();
         mutation = this.cache.transformForLink(this.transform(mutation));
         const { hasClientExports } = this.getDocumentInfo(mutation);
@@ -118,9 +135,10 @@ export class QueryManager {
                 ...context,
                 optimisticResponse: isOptimistic ? optimisticResponse : void 0,
             }, variables, {}, false)
-                .pipe(mergeMap((result) => {
-                if (graphQLResultHasError(result) && errorPolicy === "none") {
-                    throw new CombinedGraphQLErrors(getGraphQLErrorsFromResult(result));
+                .pipe(validateDidEmitValue(), mergeMap((result) => {
+                const hasErrors = graphQLResultHasError(result);
+                if (hasErrors && errorPolicy === "none") {
+                    throw new CombinedGraphQLErrors(result);
                 }
                 if (mutationStoreValue) {
                     mutationStoreValue.loading = false;
@@ -130,8 +148,7 @@ export class QueryManager {
                 if (typeof refetchQueries === "function") {
                     refetchQueries = refetchQueries(storeResult);
                 }
-                if (errorPolicy === "ignore" &&
-                    graphQLResultHasError(storeResult)) {
+                if (errorPolicy === "ignore" && hasErrors) {
                     delete storeResult.errors;
                 }
                 return from(this.markMutationResult({
@@ -160,28 +177,39 @@ export class QueryManager {
                     // ExecutionPatchResult has arrived and we have assembled the
                     // multipart response into a single result.
                     if (!("hasNext" in storeResult) || storeResult.hasNext === false) {
-                        resolve({
-                            ...storeResult,
+                        const result = {
                             data: this.maskOperation({
                                 document: mutation,
                                 data: storeResult.data,
                                 fetchPolicy,
                                 id: mutationId,
                             }),
-                        });
+                        };
+                        if (graphQLResultHasError(storeResult)) {
+                            result.error = new CombinedGraphQLErrors(storeResult);
+                        }
+                        if (storeResult.extensions) {
+                            result.extensions = storeResult.extensions;
+                        }
+                        resolve(result);
                     }
                 },
-                error: (err) => {
-                    err = maybeWrapError(err);
+                error: (error) => {
                     if (mutationStoreValue) {
                         mutationStoreValue.loading = false;
-                        mutationStoreValue.error = err;
+                        mutationStoreValue.error = error;
                     }
                     if (isOptimistic) {
                         this.cache.removeOptimistic(mutationId);
                     }
                     this.broadcastQueries();
-                    reject(err);
+                    if (errorPolicy === "ignore") {
+                        return resolve({ data: undefined });
+                    }
+                    if (errorPolicy === "all") {
+                        return resolve({ data: undefined, error });
+                    }
+                    reject(error);
                 },
             });
         });
@@ -371,7 +399,11 @@ export class QueryManager {
         return true;
     }
     fetchQuery(queryId, options, networkStatus) {
-        return lastValueFrom(this.fetchObservableWithInfo(queryId, options, networkStatus).observable, { defaultValue: undefined });
+        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 },
+        });
     }
     transform(document) {
         return this.documentTransform.transformDocument(document);
@@ -417,12 +449,15 @@ export class QueryManager {
         return transformCache.get(document);
     }
     getVariables(document, variables) {
+        const defaultVars = this.getDocumentInfo(document).defaultVars;
+        const varsWithDefaults = Object.entries(variables ?? {}).map(([key, value]) => [key, value === undefined ? defaultVars[key] : value]);
         return {
-            ...this.getDocumentInfo(document).defaultVars,
-            ...variables,
+            ...defaultVars,
+            ...Object.fromEntries(varsWithDefaults),
         };
     }
     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
@@ -432,7 +467,7 @@ export class QueryManager {
             variables: this.getVariables(query, options.variables),
         };
         if (typeof options.notifyOnNetworkStatusChange === "undefined") {
-            options.notifyOnNetworkStatusChange = false;
+            options.notifyOnNetworkStatusChange = true;
         }
         const queryInfo = new QueryInfo(this);
         const observable = new ObservableQuery({
@@ -441,35 +476,31 @@ 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;
     }
-    // TODO: catch `EmptyError` and rethrow as network error if `complete`
-    // notification is emitted without a value.
     query(options, queryId = this.generateQueryId()) {
-        invariant(options.query, 75);
-        invariant(options.query.kind === "Document", 76);
-        invariant(!options.returnPartialData, 77);
-        invariant(!options.pollInterval, 78);
         const query = this.transform(options.query);
-        return this.fetchQuery(queryId, { ...options, query })
-            .then((result) => result && {
-            ...result,
+        return this.fetchQuery(queryId, {
+            ...options,
+            query,
+        })
+            .then((value) => ({
+            ...value,
             data: this.maskOperation({
                 document: query,
-                data: result.data,
+                data: value?.data,
                 fetchPolicy: options.fetchPolicy,
                 id: queryId,
             }),
-        })
-            .finally(() => this.stopQuery(queryId));
+        }))
+            .finally(() => this.removeQuery(queryId));
     }
     queryIdCounter = 1;
     generateQueryId() {
@@ -491,7 +522,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(79));
+        this.cancelPendingFetches(newInvariantError(77));
         this.queries.forEach((queryInfo) => {
             if (queryInfo.observableQuery) {
                 // Set loading to true so listeners don't trigger unless they want
@@ -557,7 +588,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,
                 });
@@ -579,10 +610,10 @@ export class QueryManager {
                 if (!included) {
                     const queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant.warn(80, queryName);
+                        __DEV__ && invariant.warn(78, queryName);
                     }
                     else {
-                        __DEV__ && invariant.warn(81);
+                        __DEV__ && invariant.warn(79);
                     }
                 }
             });
@@ -598,51 +629,59 @@ 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((result) => {
+        const makeObservable = (variables) => this.getObservableFromLink(query, context, variables, extensions).pipe(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 (shouldWriteResult(result, errorPolicy)) {
+                if (shouldWriteResult(rawResult, errorPolicy)) {
                     this.cache.write({
                         query,
-                        result: result.data,
+                        result: rawResult.data,
                         dataId: "ROOT_SUBSCRIPTION",
                         variables: variables,
                     });
                 }
                 this.broadcastQueries();
             }
-            const hasErrors = graphQLResultHasError(result);
-            const hasProtocolErrors = graphQLResultHasProtocolErrors(result);
-            if (hasErrors && errorPolicy === "none") {
-                throw new CombinedGraphQLErrors(result.errors);
+            const result = {
+                data: rawResult.data ?? undefined,
+            };
+            if (graphQLResultHasError(rawResult)) {
+                result.error = new CombinedGraphQLErrors(rawResult);
             }
-            if (hasProtocolErrors) {
-                // `errorPolicy` is a mechanism for handling GraphQL errors, according
-                // to our documentation, so we throw protocol errors regardless of the
-                // set error policy.
-                throw result.extensions[PROTOCOL_ERRORS_SYMBOL];
+            else if (graphQLResultHasProtocolErrors(rawResult)) {
+                result.error = rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
+                // Don't emit protocol errors added by HttpLink
+                delete rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
+            }
+            if (rawResult.extensions &&
+                Object.keys(rawResult.extensions).length) {
+                result.extensions = rawResult.extensions;
+            }
+            if (result.error && errorPolicy === "none") {
+                result.data = undefined;
             }
             if (errorPolicy === "ignore") {
-                delete result.errors;
+                delete result.error;
             }
             return result;
         }), catchError((error) => {
-            throw maybeWrapError(error);
-        }));
+            if (errorPolicy === "ignore") {
+                return of({ data: undefined });
+            }
+            return of({ data: undefined, error });
+        }), filter((result) => !!(result.data || result.error)));
         if (this.getDocumentInfo(query).hasClientExports) {
             const observablePromise = this.localState
                 .addExportedVariables(query, variables, context)
@@ -655,10 +694,6 @@ export class QueryManager {
         }
         return makeObservable(variables);
     }
-    stopQuery(queryId) {
-        this.removeQuery(queryId);
-        this.broadcastQueries();
-    }
     removeQuery(queryId) {
         // teardown all links
         // Both `QueryManager.fetchRequest` and `QueryManager.query` create separate promises
@@ -667,14 +702,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;
@@ -688,16 +723,25 @@ export class QueryManager {
         this.queryDeduplication) {
         let observable;
         const { serverQuery, clientQuery } = this.getDocumentInfo(query);
+        const prepareContext = (context = {}) => {
+            const newContext = this.localState.prepareContext(context);
+            return {
+                ...this.defaultContext,
+                ...newContext,
+                queryDeduplication: deduplication,
+                clientAwareness: this.clientAwareness,
+            };
+        };
+        const executeContext = {
+            client: this.client,
+        };
         if (serverQuery) {
             const { inFlightLinkObservables, link } = this;
             const operation = {
                 query: serverQuery,
                 variables,
                 operationName: getOperationName(serverQuery) || void 0,
-                context: this.prepareContext({
-                    ...context,
-                    forceFetch: !deduplication,
-                }),
+                context: prepareContext(context),
                 extensions,
             };
             context = operation.context;
@@ -707,7 +751,7 @@ export class QueryManager {
                 const entry = inFlightLinkObservables.lookup(printedServerQuery, varJson);
                 observable = entry.observable;
                 if (!observable) {
-                    observable = entry.observable = execute(link, operation).pipe(onAnyEvent((event) => {
+                    observable = entry.observable = execute(link, operation, executeContext).pipe(onAnyEvent((event) => {
                         if ((event.type !== "next" ||
                             !("hasNext" in event.value) ||
                             !event.value.hasNext) &&
@@ -719,12 +763,12 @@ export class QueryManager {
                 }
             }
             else {
-                observable = execute(link, operation);
+                observable = execute(link, operation, executeContext);
             }
         }
         else {
             observable = of({ data: {} });
-            context = this.prepareContext(context);
+            context = prepareContext(context);
         }
         if (clientQuery) {
             observable = observable.pipe(mergeMap((result) => {
@@ -736,34 +780,30 @@ export class QueryManager {
                 }));
             }));
         }
-        return observable;
+        return observable.pipe(catchError((error) => {
+            error = toErrorLike(error);
+            registerLinkError(error);
+            throw error;
+        }));
     }
     getResultsFromLink(queryInfo, cacheWriteBehavior, options) {
         const requestId = (queryInfo.lastRequestId = this.generateRequestId());
+        const { errorPolicy } = options;
         // Performing transformForLink here gives this.cache a chance to fill in
         // missing fragment definitions (for example) before sending this document
         // through the link chain.
         const linkDocument = this.cache.transformForLink(options.query);
-        return this.getObservableFromLink(linkDocument, options.context, options.variables).pipe(catchError((error) => {
-            error = maybeWrapError(error);
-            // Avoid storing errors from older interrupted queries.
-            if (requestId >= queryInfo.lastRequestId) {
-                queryInfo.resetLastWrite();
-                queryInfo.reset();
-            }
-            throw error;
-        }), map((result) => {
+        return this.getObservableFromLink(linkDocument, options.context, options.variables).pipe(map((result) => {
             const graphQLErrors = getGraphQLErrorsFromResult(result);
             const hasErrors = graphQLErrors.length > 0;
-            const { errorPolicy } = options;
             // If we interrupted this request by calling getResultsFromLink again
             // with the same QueryInfo object, we ignore the old results.
             if (requestId >= queryInfo.lastRequestId) {
                 if (hasErrors && errorPolicy === "none") {
                     queryInfo.resetLastWrite();
-                    queryInfo.reset();
+                    queryInfo.observableQuery?.["resetNotifications"]();
                     // Throwing here effectively calls observer.error.
-                    throw new CombinedGraphQLErrors(graphQLErrors);
+                    throw new CombinedGraphQLErrors(result);
                 }
                 // Use linkDocument rather than queryInfo.document so the
                 // operation/fragments used to write the result are the same as the
@@ -784,21 +824,42 @@ export class QueryManager {
                 aqr.data = void 0;
             }
             if (hasErrors && errorPolicy !== "ignore") {
-                aqr.error = new CombinedGraphQLErrors(graphQLErrors);
+                aqr.error = new CombinedGraphQLErrors(result);
                 aqr.networkStatus = NetworkStatus.error;
             }
             return aqr;
+        }), catchError((error) => {
+            // Avoid storing errors from older interrupted queries.
+            if (requestId >= queryInfo.lastRequestId && errorPolicy === "none") {
+                queryInfo.resetLastWrite();
+                queryInfo.observableQuery?.["resetNotifications"]();
+                throw error;
+            }
+            const aqr = {
+                data: undefined,
+                loading: false,
+                networkStatus: NetworkStatus.ready,
+                partial: true,
+            };
+            if (errorPolicy !== "ignore") {
+                aqr.error = error;
+                aqr.networkStatus = NetworkStatus.error;
+            }
+            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;
+        let { fetchPolicy = (defaults && defaults.fetchPolicy) || "cache-first", errorPolicy = (defaults && defaults.errorPolicy) || "none", returnPartialData = false, notifyOnNetworkStatusChange = true, context = {}, } = options;
+        if (this.prioritizeCacheValues &&
+            (fetchPolicy === "network-only" || fetchPolicy === "cache-and-network")) {
+            fetchPolicy = "cache-first";
+        }
         const normalized = Object.assign({}, options, {
             query,
             variables,
@@ -826,13 +887,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();
         });
@@ -870,7 +931,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(),
                 });
             });
         }
@@ -956,9 +1017,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);
                 }
@@ -998,7 +1057,7 @@ export class QueryManager {
                 !isFullyUnmaskedOperation(document) &&
                 !this.noCacheWarningsByQueryId.has(operationId)) {
                 this.noCacheWarningsByQueryId.add(operationId);
-                __DEV__ && invariant.warn(82, getOperationName(document) ??
+                __DEV__ && invariant.warn(80, getOperationName(document) ??
                     `Unnamed ${operationType ?? "operation"}`);
             }
         }
@@ -1088,7 +1147,7 @@ export class QueryManager {
             context,
             fetchPolicy,
             errorPolicy,
-        });
+        }).pipe(validateDidEmitValue());
         switch (fetchPolicy) {
             default:
             case "cache-first": {
@@ -1145,36 +1204,22 @@ 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));
         }
         return this.queries.get(queryId);
     }
-    prepareContext(context = {}) {
-        const newContext = this.localState.prepareContext(context);
-        return {
-            ...this.defaultContext,
-            ...newContext,
-            clientAwareness: this.clientAwareness,
-        };
-    }
 }
-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({
+        next() {
+            didEmitValue = true;
+        },
+        complete() {
+            invariant(didEmitValue, 81);
+        },
+    });
 }
 //# sourceMappingURL=QueryManager.js.map