@apollo/client 3.6.0-beta.7 → 3.6.0-rc.0

package/apollo-client.cjs

@@ -13,6 +13,7 @@ var context = require('@wry/context');
 var trie = require('@wry/trie');
 var graphqlTag = require('graphql-tag');
 var React = require('react');
+var index_js = require('use-sync-external-store/shim/index.js');
 
 function _interopNamespace(e) {
     if (e && e.__esModule) return e;
@@ -539,7 +540,7 @@ function removeDirectivesFromDocument(directives, doc) {
     return modifiedDoc;
 }
 var addTypenameToDocument = Object.assign(function (doc) {
-    return graphql.visit(checkDocument(doc), {
+    return graphql.visit(doc, {
         SelectionSet: {
             enter: function (node, _key, parent) {
                 if (parent &&
@@ -1291,7 +1292,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.6.0-beta.7';
+var version = '3.6.0-rc.0';
 
 var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
 function parseAndCheckHttpResponse(operations) {
@@ -3906,7 +3907,6 @@ function isNetworkRequestInFlight(networkStatus) {
 }
 
 var assign = Object.assign, hasOwnProperty$2 = Object.hasOwnProperty;
-var warnedAboutUpdateQuery = false;
 var ObservableQuery = (function (_super) {
     tslib.__extends(ObservableQuery, _super);
     function ObservableQuery(_a) {
@@ -3940,11 +3940,10 @@ var ObservableQuery = (function (_super) {
         _this.observers = new Set();
         _this.subscriptions = new Set();
         _this.isTornDown = false;
-        _this.options = options;
+        _this.options = tslib.__assign({ initialFetchPolicy: options.fetchPolicy || "cache-first" }, options);
         _this.queryId = queryInfo.queryId || queryManager.generateQueryId();
         var opDef = getOperationDefinition(options.query);
         _this.queryName = opDef && opDef.name && opDef.name.value;
-        _this.initialFetchPolicy = options.fetchPolicy || "cache-first";
         _this.queryManager = queryManager;
         _this.queryInfo = queryInfo;
         return _this;
@@ -4078,35 +4077,49 @@ var ObservableQuery = (function (_super) {
         var _this = this;
         var combinedOptions = tslib.__assign(tslib.__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : tslib.__assign(tslib.__assign(tslib.__assign({}, this.options), fetchMoreOptions), { variables: tslib.__assign(tslib.__assign({}, this.options.variables), fetchMoreOptions.variables) }))), { fetchPolicy: "no-cache" });
         var qid = this.queryManager.generateQueryId();
+        var queryInfo = this.queryInfo;
+        var originalNetworkStatus = queryInfo.networkStatus;
+        queryInfo.networkStatus = exports.NetworkStatus.fetchMore;
         if (combinedOptions.notifyOnNetworkStatusChange) {
-            this.queryInfo.networkStatus = exports.NetworkStatus.fetchMore;
             this.observe();
         }
+        var updatedQuerySet = new Set();
         return this.queryManager.fetchQuery(qid, combinedOptions, exports.NetworkStatus.fetchMore).then(function (fetchMoreResult) {
-            var data = fetchMoreResult.data;
-            var updateQuery = fetchMoreOptions.updateQuery;
-            if (updateQuery) {
-                if (__DEV__ &&
-                    !warnedAboutUpdateQuery) {
-                    __DEV__ && tsInvariant.invariant.warn("The updateQuery callback for fetchMore is deprecated, and will be removed\nin the next major version of Apollo Client.\n\nPlease convert updateQuery functions to field policies with appropriate\nread and merge functions, or use/adapt a helper function (such as\nconcatPagination, offsetLimitPagination, or relayStylePagination) from\n@apollo/client/utilities.\n\nThe field policy system handles pagination more effectively than a\nhand-written updateQuery function, and you only need to define the policy\nonce, rather than every time you call fetchMore.");
-                    warnedAboutUpdateQuery = true;
-                }
-                _this.updateQuery(function (previous) { return updateQuery(previous, {
-                    fetchMoreResult: data,
-                    variables: combinedOptions.variables,
-                }); });
-            }
-            else {
-                _this.queryManager.cache.writeQuery({
-                    query: combinedOptions.query,
-                    variables: combinedOptions.variables,
-                    data: data,
-                });
-            }
+            _this.queryManager.removeQuery(qid);
+            if (queryInfo.networkStatus === exports.NetworkStatus.fetchMore) {
+                queryInfo.networkStatus = originalNetworkStatus;
+            }
+            _this.queryManager.cache.batch({
+                update: function (cache) {
+                    var updateQuery = fetchMoreOptions.updateQuery;
+                    if (updateQuery) {
+                        cache.updateQuery({
+                            query: _this.options.query,
+                            variables: _this.variables,
+                            returnPartialData: true,
+                            optimistic: false,
+                        }, function (previous) { return updateQuery(previous, {
+                            fetchMoreResult: fetchMoreResult.data,
+                            variables: combinedOptions.variables,
+                        }); });
+                    }
+                    else {
+                        cache.writeQuery({
+                            query: combinedOptions.query,
+                            variables: combinedOptions.variables,
+                            data: fetchMoreResult.data,
+                        });
+                    }
+                },
+                onWatchUpdated: function (watch) {
+                    updatedQuerySet.add(watch.query);
+                },
+            });
             return fetchMoreResult;
         }).finally(function () {
-            _this.queryManager.stopQuery(qid);
-            _this.reobserve();
+            if (!updatedQuerySet.has(_this.options.query)) {
+                reobserveCacheFirst(_this);
+            }
         });
     };
     ObservableQuery.prototype.subscribeToMore = function (options) {
@@ -4159,7 +4172,7 @@ var ObservableQuery = (function (_super) {
             return Promise.resolve();
         }
         return this.reobserve({
-            fetchPolicy: this.initialFetchPolicy,
+            fetchPolicy: this.options.initialFetchPolicy,
             variables: variables,
         }, exports.NetworkStatus.setVariables);
     };
@@ -4191,6 +4204,26 @@ var ObservableQuery = (function (_super) {
         this.options.pollInterval = 0;
         this.updatePolling();
     };
+    ObservableQuery.prototype.applyNextFetchPolicy = function (reason, options) {
+        if (options.nextFetchPolicy) {
+            var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a, _b = options.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? fetchPolicy : _b;
+            if (typeof options.nextFetchPolicy === "function") {
+                options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {
+                    reason: reason,
+                    options: options,
+                    observable: this,
+                    initialFetchPolicy: initialFetchPolicy,
+                });
+            }
+            else if (reason === "variables-changed") {
+                options.fetchPolicy = initialFetchPolicy;
+            }
+            else {
+                options.fetchPolicy = options.nextFetchPolicy;
+            }
+        }
+        return options.fetchPolicy;
+    };
     ObservableQuery.prototype.fetch = function (options, newNetworkStatus) {
         this.queryManager.setObservableQuery(this);
         return this.queryManager.fetchQueryObservable(this.queryId, options, newNetworkStatus);
@@ -4253,16 +4286,18 @@ var ObservableQuery = (function (_super) {
             newNetworkStatus === exports.NetworkStatus.fetchMore ||
             newNetworkStatus === exports.NetworkStatus.poll;
         var oldVariables = this.options.variables;
+        var oldFetchPolicy = this.options.fetchPolicy;
+        var mergedOptions = mergeOptions(this.options, newOptions || {});
         var options = useDisposableConcast
-            ? compact(this.options, newOptions)
-            : assign(this.options, compact(newOptions));
+            ? mergedOptions
+            : assign(this.options, mergedOptions);
         if (!useDisposableConcast) {
             this.updatePolling();
             if (newOptions &&
                 newOptions.variables &&
-                !newOptions.fetchPolicy &&
-                !equality.equal(newOptions.variables, oldVariables)) {
-                options.fetchPolicy = this.initialFetchPolicy;
+                !equality.equal(newOptions.variables, oldVariables) &&
+                (!newOptions.fetchPolicy || newOptions.fetchPolicy === oldFetchPolicy)) {
+                this.applyNextFetchPolicy("variables-changed", options);
                 if (newNetworkStatus === void 0) {
                     newNetworkStatus = exports.NetworkStatus.setVariables;
                 }
@@ -4326,6 +4361,23 @@ var ObservableQuery = (function (_super) {
     return ObservableQuery;
 }(zenObservableTs.Observable));
 fixObservableSubclass(ObservableQuery);
+function reobserveCacheFirst(obsQuery) {
+    var _a = obsQuery.options, fetchPolicy = _a.fetchPolicy, nextFetchPolicy = _a.nextFetchPolicy;
+    if (fetchPolicy === "cache-and-network" ||
+        fetchPolicy === "network-only") {
+        return obsQuery.reobserve({
+            fetchPolicy: "cache-first",
+            nextFetchPolicy: function () {
+                this.nextFetchPolicy = nextFetchPolicy;
+                if (typeof nextFetchPolicy === "function") {
+                    return nextFetchPolicy.apply(this, arguments);
+                }
+                return fetchPolicy;
+            },
+        });
+    }
+    return obsQuery.reobserve();
+}
 function defaultSubscriptionObserverErrorCallback(error) {
     __DEV__ && tsInvariant.invariant.error('Unhandled error', error.message, error.stack);
 }
@@ -4334,14 +4386,6 @@ function logMissingFieldErrors(missing) {
         __DEV__ && tsInvariant.invariant.debug("Missing cache result fields: ".concat(JSON.stringify(missing)), missing);
     }
 }
-function applyNextFetchPolicy(options) {
-    var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a, nextFetchPolicy = options.nextFetchPolicy;
-    if (nextFetchPolicy) {
-        options.fetchPolicy = typeof nextFetchPolicy === "function"
-            ? nextFetchPolicy.call(options, fetchPolicy)
-            : nextFetchPolicy;
-    }
-}
 
 var LocalState = (function () {
     function LocalState(_a) {
@@ -4724,11 +4768,12 @@ var QueryInfo = (function () {
         if (oq) {
             oq["queryInfo"] = this;
             this.listeners.add(this.oqListener = function () {
-                if (_this.getDiff().fromOptimisticTransaction) {
+                var diff = _this.getDiff();
+                if (diff.fromOptimisticTransaction) {
                     oq["observe"]();
                 }
                 else {
-                    oq.reobserve();
+                    reobserveCacheFirst(oq);
                 }
             });
         }
@@ -5377,8 +5422,10 @@ var QueryManager = (function () {
     };
     QueryManager.prototype.removeQuery = function (queryId) {
         this.fetchCancelFns.delete(queryId);
-        this.getQuery(queryId).stop();
-        this.queries.delete(queryId);
+        if (this.queries.has(queryId)) {
+            this.getQuery(queryId).stop();
+            this.queries.delete(queryId);
+        }
     };
     QueryManager.prototype.broadcastQueries = function () {
         if (this.onBroadcast)
@@ -5462,10 +5509,11 @@ var QueryManager = (function () {
             var aqr = {
                 data: result.data,
                 loading: false,
-                networkStatus: queryInfo.networkStatus || exports.NetworkStatus.ready,
+                networkStatus: exports.NetworkStatus.ready,
             };
             if (hasErrors && options.errorPolicy !== "ignore") {
                 aqr.errors = result.errors;
+                aqr.networkStatus = exports.NetworkStatus.error;
             }
             return aqr;
         }, function (networkError) {
@@ -5507,7 +5555,9 @@ var QueryManager = (function () {
             : fromVariables(normalized.variables));
         concast.cleanup(function () {
             _this.fetchCancelFns.delete(queryId);
-            applyNextFetchPolicy(options);
+            if (queryInfo.observableQuery) {
+                queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
+            }
         });
         return concast;
     };
@@ -5581,7 +5631,7 @@ var QueryManager = (function () {
     };
     QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a, networkStatus) {
         var _this = this;
-        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;
+        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange, fetchBlockingPromise = _a.fetchBlockingPromise;
         var oldNetworkStatus = queryInfo.networkStatus;
         queryInfo.init({
             document: query,
@@ -5614,12 +5664,26 @@ var QueryManager = (function () {
                 refetchWritePolicy !== "merge") ? 1
                 : 2;
         var resultsFromLink = function () {
-            return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
+            var get = function () { return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
                 variables: variables,
                 context: context,
                 fetchPolicy: fetchPolicy,
                 errorPolicy: errorPolicy,
-            });
+            }); };
+            return fetchBlockingPromise ? fetchBlockingPromise.then(function (ok) { return ok ? get() : zenObservableTs.Observable.of(); }, function (error) {
+                var apolloError = isApolloError(error)
+                    ? error
+                    : new ApolloError({ clientErrors: [error] });
+                if (errorPolicy !== "ignore") {
+                    queryInfo.markError(apolloError);
+                }
+                return zenObservableTs.Observable.of({
+                    loading: false,
+                    networkStatus: exports.NetworkStatus.error,
+                    error: apolloError,
+                    data: readCache().result,
+                });
+            }) : get();
         };
         var shouldNotify = notifyOnNetworkStatusChange &&
             typeof oldNetworkStatus === "number" &&
@@ -6059,7 +6123,8 @@ function verifyDocumentType(document, type) {
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 function useQuery(query, options) {
-    return useInternalState(useApolloClient(options && options.client), query).useQuery(options);
+    if (options === void 0) { options = Object.create(null); }
+    return useInternalState(useApolloClient(options.client), query).useQuery(options);
 }
 function useInternalState(client, query) {
     var stateRef = React.useRef();
@@ -6079,118 +6144,31 @@ var InternalState = (function () {
     function InternalState(client, query) {
         this.client = client;
         this.query = query;
+        this.ssrDisabledResult = maybeDeepFreeze({
+            loading: true,
+            data: void 0,
+            error: void 0,
+            networkStatus: exports.NetworkStatus.loading,
+        });
+        this.skipStandbyResult = maybeDeepFreeze({
+            loading: false,
+            data: void 0,
+            error: void 0,
+            networkStatus: exports.NetworkStatus.ready,
+        });
         this.toQueryResultCache = new (canUseWeakMap ? WeakMap : Map)();
         verifyDocumentType(query, exports.DocumentType.Query);
     }
     InternalState.prototype.forceUpdate = function () {
     };
     InternalState.prototype.useQuery = function (options) {
+        var _this = this;
+        this.renderPromises = React.useContext(getApolloContext()).renderPromises;
         this.useOptions(options);
         var obsQuery = this.useObservableQuery();
-        this.useSubscriptionEffect(obsQuery);
-        var result = this.getCurrentResult();
-        this.unsafeHandlePartialRefetch(result);
-        return this.toQueryResult(result);
-    };
-    InternalState.prototype.useOptions = function (options) {
-        this.renderPromises = React.useContext(getApolloContext()).renderPromises;
-        var watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options || {});
-        if (!equality.equal(watchQueryOptions, this.watchQueryOptions)) {
-            this.watchQueryOptions = watchQueryOptions;
-        }
-        this.ssrDisabled = !!(options && (options.ssr === false ||
-            options.skip));
-        this.onCompleted = options
-            && options.onCompleted
-            || InternalState.prototype.onCompleted;
-        this.onError = options
-            && options.onError
-            || InternalState.prototype.onError;
-    };
-    InternalState.prototype.createWatchQueryOptions = function (_a) {
-        var _b;
-        if (_a === void 0) { _a = {}; }
-        var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; _a.displayName; var otherOptions = tslib.__rest(_a, ["skip", "ssr", "onCompleted", "onError", "displayName"]);
-        var watchQueryOptions = Object.assign(otherOptions, { query: this.query });
-        if (skip) {
-            watchQueryOptions.fetchPolicy = 'standby';
-        }
-        else if (((_b = watchQueryOptions.context) === null || _b === void 0 ? void 0 : _b.renderPromises) &&
-            (watchQueryOptions.fetchPolicy === 'network-only' ||
-                watchQueryOptions.fetchPolicy === 'cache-and-network')) {
-            watchQueryOptions.fetchPolicy = 'cache-first';
-        }
-        else if (!watchQueryOptions.fetchPolicy) {
-            var defaultOptions = this.client.defaultOptions.watchQuery;
-            watchQueryOptions.fetchPolicy =
-                defaultOptions && defaultOptions.fetchPolicy || 'cache-first';
-        }
-        if (!watchQueryOptions.variables) {
-            watchQueryOptions.variables = {};
-        }
-        return watchQueryOptions;
-    };
-    InternalState.prototype.onCompleted = function (data) { };
-    InternalState.prototype.onError = function (error) { };
-    InternalState.prototype.useObservableQuery = function () {
-        var _this = this;
-        var obsQuery = this.observable =
-            this.renderPromises
-                && this.renderPromises.getSSRObservable(this.watchQueryOptions)
-                || this.observable
-                || this.client.watchQuery(this.watchQueryOptions);
-        this.obsQueryFields = React.useMemo(function () { return ({
-            refetch: obsQuery.refetch.bind(obsQuery),
-            fetchMore: obsQuery.fetchMore.bind(obsQuery),
-            updateQuery: obsQuery.updateQuery.bind(obsQuery),
-            startPolling: obsQuery.startPolling.bind(obsQuery),
-            stopPolling: obsQuery.stopPolling.bind(obsQuery),
-            subscribeToMore: obsQuery.subscribeToMore.bind(obsQuery),
-        }); }, [obsQuery]);
-        if (this.renderPromises) {
-            this.renderPromises.registerSSRObservable(obsQuery);
-            if (!this.ssrDisabled && obsQuery.getCurrentResult().loading) {
-                this.renderPromises.addQueryPromise({
-                    getOptions: function () { return obsQuery.options; },
-                    fetchData: function () { return new Promise(function (resolve) {
-                        var sub = obsQuery.subscribe({
-                            next: function (result) {
-                                if (!result.loading) {
-                                    resolve();
-                                    sub.unsubscribe();
-                                }
-                            },
-                            error: function () {
-                                resolve();
-                                sub.unsubscribe();
-                            },
-                            complete: function () {
-                                resolve();
-                            },
-                        });
-                    }); },
-                }, function () { return null; });
-                obsQuery.setOptions(this.watchQueryOptions).catch(function () { });
-            }
-        }
-        var prevOptionsRef = React.useRef({
-            watchQueryOptions: this.watchQueryOptions,
-        });
-        React.useEffect(function () {
-            if (_this.renderPromises) ;
-            else if (_this.watchQueryOptions !== prevOptionsRef.current.watchQueryOptions) {
-                obsQuery.setOptions(_this.watchQueryOptions).catch(function () { });
-                prevOptionsRef.current.watchQueryOptions = _this.watchQueryOptions;
-                _this.setResult(obsQuery.getCurrentResult());
-            }
-        }, [obsQuery, this.watchQueryOptions]);
-        return obsQuery;
-    };
-    InternalState.prototype.useSubscriptionEffect = function (obsQuery) {
-        var _this = this;
-        React.useEffect(function () {
+        var result = index_js.useSyncExternalStore(React.useCallback(function () {
             if (_this.renderPromises) {
-                return;
+                return function () { };
             }
             var onNext = function () {
                 var previousResult = _this.result;
@@ -6234,7 +6212,117 @@ var InternalState = (function () {
             obsQuery,
             this.renderPromises,
             this.client.disableNetworkFetches,
-        ]);
+        ]), function () { return _this.getCurrentResult(); });
+        this.unsafeHandlePartialRefetch(result);
+        return this.toQueryResult(result);
+    };
+    InternalState.prototype.useOptions = function (options) {
+        var _a;
+        var watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options);
+        var currentWatchQueryOptions = this.watchQueryOptions;
+        var resolveFetchBlockingPromise;
+        if (!equality.equal(watchQueryOptions, currentWatchQueryOptions)) {
+            this.watchQueryOptions = watchQueryOptions;
+            if (currentWatchQueryOptions && this.observable) {
+                this.observable.reobserve(tslib.__assign({ fetchBlockingPromise: new Promise(function (resolve) {
+                        resolveFetchBlockingPromise = resolve;
+                    }) }, watchQueryOptions));
+                this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
+                this.result = void 0;
+            }
+        }
+        useUnblockFetchEffect(this.renderPromises, resolveFetchBlockingPromise);
+        this.ssrDisabled = !!(options.ssr === false ||
+            options.skip);
+        this.onCompleted = options.onCompleted || InternalState.prototype.onCompleted;
+        this.onError = options.onError || InternalState.prototype.onError;
+        if ((this.renderPromises || this.client.disableNetworkFetches) &&
+            this.queryHookOptions.ssr === false) {
+            this.result = this.ssrDisabledResult;
+        }
+        else if (this.queryHookOptions.skip ||
+            this.watchQueryOptions.fetchPolicy === 'standby') {
+            this.result = this.skipStandbyResult;
+        }
+        else if (this.result === this.ssrDisabledResult ||
+            this.result === this.skipStandbyResult) {
+            this.result = void 0;
+        }
+    };
+    InternalState.prototype.createWatchQueryOptions = function (_a) {
+        if (_a === void 0) { _a = {}; }
+        var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; _a.displayName; var defaultOptions = _a.defaultOptions, otherOptions = tslib.__rest(_a, ["skip", "ssr", "onCompleted", "onError", "displayName", "defaultOptions"]);
+        var toMerge = [];
+        var globalDefaults = this.client.defaultOptions.watchQuery;
+        if (globalDefaults)
+            toMerge.push(globalDefaults);
+        if (defaultOptions)
+            toMerge.push(defaultOptions);
+        var latestOptions = this.observable && this.observable.options;
+        if (latestOptions && toMerge.length) {
+            var defaults_1 = toMerge.reduce(mergeOptions, Object.create(null));
+            toMerge.length = 1;
+            toMerge[0] = defaults_1;
+            Object.keys(defaults_1).forEach(function (defaultOptionName) {
+                var currentOptionValue = latestOptions[defaultOptionName];
+                if (hasOwnProperty.call(latestOptions, defaultOptionName) &&
+                    !equality.equal(defaults_1[defaultOptionName], currentOptionValue)) {
+                    defaults_1[defaultOptionName] = defaultOptionName === "variables"
+                        ? tslib.__assign(tslib.__assign({}, defaults_1.variables), currentOptionValue) : currentOptionValue;
+                }
+            });
+        }
+        toMerge.push(otherOptions);
+        var merged = toMerge.reduce(mergeOptions, Object.create(null));
+        var watchQueryOptions = Object.assign(merged, { query: this.query });
+        if (this.renderPromises &&
+            (watchQueryOptions.fetchPolicy === 'network-only' ||
+                watchQueryOptions.fetchPolicy === 'cache-and-network')) {
+            watchQueryOptions.fetchPolicy = 'cache-first';
+        }
+        else if (!watchQueryOptions.fetchPolicy) {
+            watchQueryOptions.fetchPolicy = 'cache-first';
+        }
+        if (skip) {
+            var _b = watchQueryOptions.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? watchQueryOptions.fetchPolicy : _b;
+            Object.assign(watchQueryOptions, {
+                initialFetchPolicy: initialFetchPolicy,
+                fetchPolicy: 'standby',
+            });
+        }
+        if (!watchQueryOptions.variables) {
+            watchQueryOptions.variables = {};
+        }
+        return watchQueryOptions;
+    };
+    InternalState.prototype.onCompleted = function (data) { };
+    InternalState.prototype.onError = function (error) { };
+    InternalState.prototype.useObservableQuery = function () {
+        var resolveFetchBlockingPromise;
+        var obsQuery = this.observable =
+            this.renderPromises
+                && this.renderPromises.getSSRObservable(this.watchQueryOptions)
+                || this.observable
+                || this.client.watchQuery(tslib.__assign({ fetchBlockingPromise: new Promise(function (resolve) {
+                        resolveFetchBlockingPromise = resolve;
+                    }) }, this.watchQueryOptions));
+        useUnblockFetchEffect(this.renderPromises, resolveFetchBlockingPromise);
+        this.obsQueryFields = React.useMemo(function () { return ({
+            refetch: obsQuery.refetch.bind(obsQuery),
+            reobserve: obsQuery.reobserve.bind(obsQuery),
+            fetchMore: obsQuery.fetchMore.bind(obsQuery),
+            updateQuery: obsQuery.updateQuery.bind(obsQuery),
+            startPolling: obsQuery.startPolling.bind(obsQuery),
+            stopPolling: obsQuery.stopPolling.bind(obsQuery),
+            subscribeToMore: obsQuery.subscribeToMore.bind(obsQuery),
+        }); }, [obsQuery]);
+        if (this.renderPromises) {
+            this.renderPromises.registerSSRObservable(obsQuery);
+            if (!this.ssrDisabled && obsQuery.getCurrentResult().loading) {
+                this.renderPromises.addObservableQueryPromise(obsQuery);
+            }
+        }
+        return obsQuery;
     };
     InternalState.prototype.setResult = function (nextResult) {
         var previousResult = this.result;
@@ -6256,30 +6344,10 @@ var InternalState = (function () {
         }
     };
     InternalState.prototype.getCurrentResult = function () {
-        var result = this.result;
-        if (!result) {
-            result = this.result = this.observable.getCurrentResult();
-            this.handleErrorOrCompleted(result);
+        if (!this.result) {
+            this.handleErrorOrCompleted(this.result = this.observable.getCurrentResult());
         }
-        if ((this.renderPromises || this.client.disableNetworkFetches) &&
-            this.queryHookOptions.ssr === false) {
-            result = {
-                loading: true,
-                data: void 0,
-                error: void 0,
-                networkStatus: exports.NetworkStatus.loading,
-            };
-        }
-        else if (this.queryHookOptions.skip ||
-            this.queryHookOptions.fetchPolicy === 'standby') {
-            result = {
-                loading: false,
-                data: void 0,
-                error: void 0,
-                networkStatus: exports.NetworkStatus.ready,
-            };
-        }
-        return result;
+        return this.result;
     };
     InternalState.prototype.toQueryResult = function (result) {
         var queryResult = this.toQueryResultCache.get(result);
@@ -6307,33 +6375,52 @@ var InternalState = (function () {
     };
     return InternalState;
 }());
+function useUnblockFetchEffect(renderPromises, resolveFetchBlockingPromise) {
+    if (resolveFetchBlockingPromise) {
+        if (renderPromises) {
+            resolveFetchBlockingPromise(true);
+        }
+        else {
+            setTimeout(function () { return resolveFetchBlockingPromise(false); }, 5000);
+        }
+    }
+    React.useEffect(function () {
+        if (resolveFetchBlockingPromise) {
+            resolveFetchBlockingPromise(true);
+        }
+    }, [resolveFetchBlockingPromise]);
+}
 
 var EAGER_METHODS = [
     'refetch',
+    'reobserve',
     'fetchMore',
     'updateQuery',
     'startPolling',
     'subscribeToMore',
 ];
 function useLazyQuery(query, options) {
-    var _a = React.useState({
-        called: false,
-    }), execution = _a[0], setExecution = _a[1];
-    var result = useQuery(query, tslib.__assign(tslib.__assign(tslib.__assign({}, options), execution.options), { fetchPolicy: execution.called ? options === null || options === void 0 ? void 0 : options.fetchPolicy : 'standby', skip: undefined }));
-    if (!execution.called) {
-        result = tslib.__assign(tslib.__assign({}, result), { loading: false, data: void 0, error: void 0, called: false });
-    }
+    var internalState = useInternalState(useApolloClient(options && options.client), query);
+    var execOptionsRef = React.useRef();
+    var defaultOptions = internalState.client.defaultOptions.watchQuery;
+    var initialFetchPolicy = (options && options.fetchPolicy) ||
+        (execOptionsRef.current && execOptionsRef.current.fetchPolicy) ||
+        (defaultOptions && defaultOptions.fetchPolicy) ||
+        "cache-first";
+    var useQueryResult = internalState.useQuery(tslib.__assign(tslib.__assign(tslib.__assign({}, options), execOptionsRef.current), { skip: !execOptionsRef.current }));
+    var result = Object.assign(useQueryResult, {
+        called: !!execOptionsRef.current,
+    });
     var eagerMethods = React.useMemo(function () {
         var eagerMethods = {};
         var _loop_1 = function (key) {
             var method = result[key];
             eagerMethods[key] = function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
+                if (!execOptionsRef.current) {
+                    execOptionsRef.current = Object.create(null);
+                    internalState.forceUpdate();
                 }
-                setExecution(function (execution) { return (tslib.__assign(tslib.__assign({}, execution), { called: true })); });
-                return method.apply(void 0, args);
+                return method.apply(this, arguments);
             };
         };
         for (var _i = 0, EAGER_METHODS_1 = EAGER_METHODS; _i < EAGER_METHODS_1.length; _i++) {
@@ -6342,15 +6429,24 @@ function useLazyQuery(query, options) {
         }
         return eagerMethods;
     }, []);
-    result.error = result.error || void 0;
     Object.assign(result, eagerMethods);
     var execute = React.useCallback(function (executeOptions) {
-        setExecution({ called: true, options: executeOptions });
-        var promise = result.refetch(executeOptions === null || executeOptions === void 0 ? void 0 : executeOptions.variables).then(function (result1) {
-            var result2 = tslib.__assign(tslib.__assign({}, result), { data: result1.data, error: result1.error, called: true, loading: false });
-            Object.assign(result2, eagerMethods);
-            return result2;
-        });
+        var promise = result.reobserve(execOptionsRef.current = executeOptions ? tslib.__assign(tslib.__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
+            fetchPolicy: initialFetchPolicy,
+        }).then(function (apolloQueryResult) {
+            apolloQueryResult = apolloQueryResult || internalState["getCurrentResult"]();
+            if (apolloQueryResult.error ||
+                isNonEmptyArray(apolloQueryResult.errors)) {
+                var _a = result.observable.options.errorPolicy, errorPolicy = _a === void 0 ? "none" : _a;
+                if (errorPolicy === "none") {
+                    throw apolloQueryResult.error || new ApolloError({
+                        graphQLErrors: apolloQueryResult.errors,
+                    });
+                }
+            }
+            return internalState.toQueryResult(apolloQueryResult);
+        }).then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
+        internalState.forceUpdate();
         promise.catch(function () { });
         return promise;
     }, []);
@@ -6574,7 +6670,6 @@ exports.HttpLink = HttpLink;
 exports.InMemoryCache = InMemoryCache;
 exports.MissingFieldError = MissingFieldError;
 exports.ObservableQuery = ObservableQuery;
-exports.applyNextFetchPolicy = applyNextFetchPolicy;
 exports.checkFetcher = checkFetcher;
 exports.concat = concat;
 exports.createHttpLink = createHttpLink;