@apollo/client 3.8.0-beta.3 → 3.8.0-beta.5

package/apollo-client.cjs

@@ -6,7 +6,7 @@ var tslib = require('tslib');
 var process$1 = require('ts-invariant/process');
 var graphql = require('graphql');
 var equal = require('@wry/equality');
-var tsInvariant = require('ts-invariant');
+var invariant$1 = require('ts-invariant');
 var zenObservableTs = require('zen-observable-ts');
 require('symbol-observable');
 var optimism = require('optimism');
@@ -30,10 +30,11 @@ function _interopNamespace(e) {
 }
 
 var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
+var invariant__default = /*#__PURE__*/_interopDefaultLegacy(invariant$1);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
-var version = '3.8.0-beta.3';
+var version = '3.8.0-beta.5';
 
 function maybe(thunk) {
     try {
@@ -78,20 +79,20 @@ var invariant = Object.assign(function invariant(condition, message) {
         args[_i - 2] = arguments[_i];
     }
     if (!condition) {
-        tsInvariant.invariant(condition, getErrorMsg(message, args));
+        invariant$1.invariant(condition, getErrorMsg(message, args));
     }
 }, {
-    debug: wrap(tsInvariant.invariant.debug),
-    log: wrap(tsInvariant.invariant.log),
-    warn: wrap(tsInvariant.invariant.warn),
-    error: wrap(tsInvariant.invariant.error),
+    debug: wrap(invariant$1.invariant.debug),
+    log: wrap(invariant$1.invariant.log),
+    warn: wrap(invariant$1.invariant.warn),
+    error: wrap(invariant$1.invariant.error),
 });
 function newInvariantError(message) {
     var optionalParams = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         optionalParams[_i - 1] = arguments[_i];
     }
-    return new tsInvariant.InvariantError(getErrorMsg(message, optionalParams));
+    return new invariant$1.InvariantError(getErrorMsg(message, optionalParams));
 }
 var ApolloErrorMessageHandler = Symbol.for('ApolloErrorMessageHandler_' + version);
 function getErrorMsg(message, messageArgs) {
@@ -4622,6 +4623,7 @@ var ObservableQuery = (function (_super) {
         _this.subscriptions = new Set();
         _this.queryInfo = queryInfo;
         _this.queryManager = queryManager;
+        _this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);
         _this.isTornDown = false;
         var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? "cache-first" : _d;
         var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e, _f = options.initialFetchPolicy, initialFetchPolicy = _f === void 0 ? (fetchPolicy === "standby" ? defaultFetchPolicy : fetchPolicy) : _f;
@@ -4672,10 +4674,11 @@ var ObservableQuery = (function (_super) {
             exports.NetworkStatus.ready;
         var result = tslib.__assign(tslib.__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });
         var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a;
-        if (fetchPolicy === 'network-only' ||
-            fetchPolicy === 'no-cache' ||
-            fetchPolicy === 'standby' ||
+        if (skipCacheDataFor(fetchPolicy) ||
             this.queryManager.getDocumentInfo(this.query).hasForcedResolvers) ;
+        else if (this.waitForOwnResult) {
+            this.queryInfo['updateWatch']();
+        }
         else {
             var diff = this.queryInfo.getDiff();
             if (diff.complete || this.options.returnPartialData) {
@@ -5013,13 +5016,21 @@ var ObservableQuery = (function (_super) {
             }
         }
         var fetchOptions = query === options.query ? options : tslib.__assign(tslib.__assign({}, options), { query: query });
-        var variables = options.variables && tslib.__assign({}, options.variables);
+        this.waitForOwnResult && (this.waitForOwnResult = skipCacheDataFor(fetchOptions.fetchPolicy));
+        var finishWaitingForOwnResult = function () {
+            if (_this.concast === concast) {
+                _this.waitForOwnResult = false;
+            }
+        };
+        var variables = fetchOptions.variables && tslib.__assign({}, fetchOptions.variables);
         var _a = this.fetch(fetchOptions, newNetworkStatus), concast = _a.concast, fromLink = _a.fromLink;
         var observer = {
             next: function (result) {
+                finishWaitingForOwnResult();
                 _this.reportResult(result, variables);
             },
             error: function (error) {
+                finishWaitingForOwnResult();
                 _this.reportError(error, variables);
             },
         };
@@ -5103,6 +5114,9 @@ function logMissingFieldErrors(missing) {
         __DEV__ && invariant.debug(23, missing);
     }
 }
+function skipCacheDataFor(fetchPolicy) {
+    return fetchPolicy === "network-only" || fetchPolicy === "no-cache" || fetchPolicy === "standby";
+}
 
 var LocalState = (function () {
     function LocalState(_a) {
@@ -7034,7 +7048,7 @@ var InternalState = (function () {
         }
     }
     InternalState.prototype.forceUpdate = function () {
-        __DEV__ && invariant.warn(50);
+        __DEV__ && invariant.warn(49);
     };
     InternalState.prototype.executeQuery = function (options) {
         var _this = this;
@@ -7667,15 +7681,20 @@ function useSuspenseQuery(query, options) {
     if (options === void 0) { options = Object.create(null); }
     var client = useApolloClient(options.client);
     var suspenseCache = useSuspenseCache(options.suspenseCache);
-    var watchQueryOptions = useWatchQueryOptions({ query: query, options: options });
-    var variables = watchQueryOptions.variables;
+    var watchQueryOptions = useWatchQueryOptions({ client: client, query: query, options: options });
+    var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;
     var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
     var cacheKey = [client, query, canonicalStringify(variables)].concat(queryKey);
     var queryRef = suspenseCache.getQueryRef(cacheKey, function () {
         return client.watchQuery(watchQueryOptions);
     });
+    var currentFetchPolicy = queryRef.watchQueryOptions.fetchPolicy;
     var _b = React.useState(function () { return new Map([[queryRef.key, queryRef.promise]]); }), promiseCache = _b[0], setPromiseCache = _b[1];
     var promise = promiseCache.get(queryRef.key);
+    if (currentFetchPolicy === 'standby' && fetchPolicy !== currentFetchPolicy) {
+        promise = queryRef.reobserve({ fetchPolicy: fetchPolicy });
+        promiseCache.set(queryRef.key, promise);
+    }
     if (!promise) {
         promise = queryRef.promise;
         promiseCache.set(queryRef.key, promise);
@@ -7688,7 +7707,16 @@ function useSuspenseQuery(query, options) {
             });
         });
     }, [queryRef]);
-    var result = __use(promise);
+    var skipResult = React.useMemo(function () {
+        var error = toApolloError(queryRef.result);
+        return {
+            loading: false,
+            data: queryRef.result.data,
+            networkStatus: error ? exports.NetworkStatus.error : exports.NetworkStatus.ready,
+            error: error,
+        };
+    }, [queryRef.result]);
+    var result = watchQueryOptions.fetchPolicy === 'standby' ? skipResult : __use(promise);
     var fetchMore = React.useCallback(function (options) {
         var promise = queryRef.fetchMore(options);
         setPromiseCache(function (previousPromiseCache) {
@@ -7750,78 +7778,26 @@ function useTrackedQueryRefs(queryRef) {
     });
 }
 function useWatchQueryOptions(_a) {
-    var query = _a.query, options = _a.options;
-    var watchQueryOptions = useDeepMemo(function () { return (tslib.__assign(tslib.__assign({}, options), { query: query, notifyOnNetworkStatusChange: false, nextFetchPolicy: void 0 })); }, [options, query]);
-    if (__DEV__) {
-        validateOptions(watchQueryOptions);
-    }
-    return watchQueryOptions;
-}
-
-function useBackgroundQuery(query, options) {
-    if (options === void 0) { options = Object.create(null); }
-    var suspenseCache = useSuspenseCache(options.suspenseCache);
-    var client = useApolloClient(options.client);
-    var watchQueryOptions = useWatchQueryOptions({ query: query, options: options });
-    var variables = watchQueryOptions.variables;
-    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
-    var cacheKey = [client, query, canonicalStringify(variables)].concat(queryKey);
-    var queryRef = suspenseCache.getQueryRef(cacheKey, function () {
-        return client.watchQuery(watchQueryOptions);
-    });
-    var _b = React.useState(function () { return new Map([[queryRef.key, queryRef.promise]]); }), promiseCache = _b[0], setPromiseCache = _b[1];
-    useTrackedQueryRefs(queryRef);
-    var fetchMore = React.useCallback(function (options) {
-        var promise = queryRef.fetchMore(options);
-        setPromiseCache(function (promiseCache) {
-            return new Map(promiseCache).set(queryRef.key, promise);
-        });
-        return promise;
-    }, [queryRef]);
-    var refetch = React.useCallback(function (variables) {
-        var promise = queryRef.refetch(variables);
-        setPromiseCache(function (promiseCache) {
-            return new Map(promiseCache).set(queryRef.key, promise);
-        });
-        return promise;
-    }, [queryRef]);
-    queryRef.promiseCache = promiseCache;
-    return React.useMemo(function () {
-        return [
-            queryRef,
-            {
-                fetchMore: fetchMore,
-                refetch: refetch,
-            },
-        ];
-    }, [queryRef, fetchMore, refetch]);
-}
-function useReadQuery(queryRef) {
-    var _a = React.useState(0), forceUpdate = _a[1];
-    invariant(queryRef.promiseCache, 49);
-    var promise = queryRef.promiseCache.get(queryRef.key);
-    if (!promise) {
-        promise = queryRef.promise;
-        queryRef.promiseCache.set(queryRef.key, promise);
-    }
-    React.useEffect(function () {
-        return queryRef.listen(function (promise) {
-            queryRef.promiseCache.set(queryRef.key, promise);
-            forceUpdate(function (prevState) { return prevState + 1; });
-        });
-    }, [queryRef]);
-    var result = __use(promise);
-    return React.useMemo(function () {
-        return {
-            data: result.data,
-            networkStatus: result.networkStatus,
-            error: toApolloError(result),
-        };
-    }, [result]);
+    var client = _a.client, query = _a.query, options = _a.options;
+    return useDeepMemo(function () {
+        var _a;
+        var fetchPolicy = options.fetchPolicy ||
+            ((_a = client.defaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||
+            'cache-first';
+        var watchQueryOptions = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: fetchPolicy, query: query, notifyOnNetworkStatusChange: false, nextFetchPolicy: void 0 });
+        if (__DEV__) {
+            validateOptions(watchQueryOptions);
+        }
+        if (options.skip) {
+            watchQueryOptions.fetchPolicy = 'standby';
+        }
+        return watchQueryOptions;
+    }, [client, options, query]);
 }
 
-var QueryReference = (function () {
-    function QueryReference(observable, options) {
+var QUERY_REFERENCE_SYMBOL = Symbol();
+var InternalQueryReference = (function () {
+    function InternalQueryReference(observable, options) {
         var _this = this;
         var _a;
         this.listeners = new Set();
@@ -7856,7 +7832,14 @@ var QueryReference = (function () {
         }
         this.autoDisposeTimeoutId = setTimeout(this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);
     }
-    QueryReference.prototype.listen = function (listener) {
+    Object.defineProperty(InternalQueryReference.prototype, "watchQueryOptions", {
+        get: function () {
+            return this.observable.options;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    InternalQueryReference.prototype.listen = function (listener) {
         var _this = this;
         clearTimeout(this.autoDisposeTimeoutId);
         this.listeners.add(listener);
@@ -7864,24 +7847,29 @@ var QueryReference = (function () {
             _this.listeners.delete(listener);
         };
     };
-    QueryReference.prototype.refetch = function (variables) {
+    InternalQueryReference.prototype.refetch = function (variables) {
         this.refetching = true;
         var promise = this.observable.refetch(variables);
         this.promise = promise;
         return promise;
     };
-    QueryReference.prototype.fetchMore = function (options) {
+    InternalQueryReference.prototype.fetchMore = function (options) {
         var promise = this.observable.fetchMore(options);
         this.promise = promise;
         return promise;
     };
-    QueryReference.prototype.dispose = function () {
+    InternalQueryReference.prototype.reobserve = function (watchQueryOptions) {
+        var promise = this.observable.reobserve(watchQueryOptions);
+        this.promise = promise;
+        return promise;
+    };
+    InternalQueryReference.prototype.dispose = function () {
         this.subscription.unsubscribe();
         this.onDispose();
     };
-    QueryReference.prototype.onDispose = function () {
+    InternalQueryReference.prototype.onDispose = function () {
     };
-    QueryReference.prototype.handleNext = function (result) {
+    InternalQueryReference.prototype.handleNext = function (result) {
         if (!this.initialized || this.refetching) {
             if (!isNetworkRequestSettled(result.networkStatus)) {
                 return;
@@ -7892,7 +7880,9 @@ var QueryReference = (function () {
             this.initialized = true;
             this.refetching = false;
             this.result = result;
-            this.resolve(result);
+            if (this.resolve) {
+                this.resolve(result);
+            }
             return;
         }
         if (result.data === this.result.data) {
@@ -7902,13 +7892,15 @@ var QueryReference = (function () {
         this.promise = createFulfilledPromise(result);
         this.deliver(this.promise);
     };
-    QueryReference.prototype.handleError = function (error) {
+    InternalQueryReference.prototype.handleError = function (error) {
         var result = tslib.__assign(tslib.__assign({}, this.result), { error: error, networkStatus: exports.NetworkStatus.error });
         this.result = result;
         if (!this.initialized || this.refetching) {
             this.initialized = true;
             this.refetching = false;
-            this.reject(error);
+            if (this.reject) {
+                this.reject(error);
+            }
             return;
         }
         this.result = result;
@@ -7917,12 +7909,93 @@ var QueryReference = (function () {
             : createRejectedPromise(result);
         this.deliver(this.promise);
     };
-    QueryReference.prototype.deliver = function (promise) {
+    InternalQueryReference.prototype.deliver = function (promise) {
         this.listeners.forEach(function (listener) { return listener(promise); });
     };
-    return QueryReference;
+    return InternalQueryReference;
 }());
 
+function useBackgroundQuery(query, options) {
+    if (options === void 0) { options = Object.create(null); }
+    var suspenseCache = useSuspenseCache(options.suspenseCache);
+    var client = useApolloClient(options.client);
+    var watchQueryOptions = useWatchQueryOptions({ client: client, query: query, options: options });
+    var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;
+    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;
+    var cacheKey = [client, query, canonicalStringify(variables)].concat(queryKey);
+    var queryRef = suspenseCache.getQueryRef(cacheKey, function () {
+        return client.watchQuery(watchQueryOptions);
+    });
+    var currentFetchPolicy = queryRef.watchQueryOptions.fetchPolicy;
+    var _b = React.useState(function () { return new Map([[queryRef.key, queryRef.promise]]); }), promiseCache = _b[0], setPromiseCache = _b[1];
+    if (currentFetchPolicy === 'standby' && fetchPolicy !== currentFetchPolicy) {
+        var promise = queryRef.reobserve({ fetchPolicy: fetchPolicy });
+        promiseCache.set(queryRef.key, promise);
+    }
+    useTrackedQueryRefs(queryRef);
+    var fetchMore = React.useCallback(function (options) {
+        var promise = queryRef.fetchMore(options);
+        setPromiseCache(function (promiseCache) {
+            return new Map(promiseCache).set(queryRef.key, promise);
+        });
+        return promise;
+    }, [queryRef]);
+    var refetch = React.useCallback(function (variables) {
+        var promise = queryRef.refetch(variables);
+        setPromiseCache(function (promiseCache) {
+            return new Map(promiseCache).set(queryRef.key, promise);
+        });
+        return promise;
+    }, [queryRef]);
+    queryRef.promiseCache = promiseCache;
+    return React.useMemo(function () {
+        var _a;
+        return [
+            (_a = {}, _a[QUERY_REFERENCE_SYMBOL] = queryRef, _a),
+            {
+                fetchMore: fetchMore,
+                refetch: refetch,
+            },
+        ];
+    }, [queryRef, fetchMore, refetch]);
+}
+
+function useReadQuery(queryRef) {
+    var _a = React.useState(0), forceUpdate = _a[1];
+    var internalQueryRef = queryRef[QUERY_REFERENCE_SYMBOL];
+    invariant__default(internalQueryRef.promiseCache, 50);
+    var skipResult = React.useMemo(function () {
+        var error = toApolloError(internalQueryRef.result);
+        return {
+            loading: false,
+            data: internalQueryRef.result.data,
+            networkStatus: error ? exports.NetworkStatus.error : exports.NetworkStatus.ready,
+            error: error,
+        };
+    }, [internalQueryRef.result]);
+    var promise = internalQueryRef.promiseCache.get(internalQueryRef.key);
+    if (!promise) {
+        promise = internalQueryRef.promise;
+        internalQueryRef.promiseCache.set(internalQueryRef.key, promise);
+    }
+    React.useEffect(function () {
+        return internalQueryRef.listen(function (promise) {
+            internalQueryRef.promiseCache.set(internalQueryRef.key, promise);
+            forceUpdate(function (prevState) { return prevState + 1; });
+        });
+    }, [queryRef]);
+    var result = internalQueryRef.watchQueryOptions.fetchPolicy === 'standby'
+        ? skipResult
+        : __use(promise);
+    return React.useMemo(function () {
+        return {
+            data: result.data,
+            networkStatus: result.networkStatus,
+            error: toApolloError(result),
+        };
+    }, [result]);
+}
+
 var SuspenseCache = (function () {
     function SuspenseCache(options) {
         if (options === void 0) { options = Object.create(null); }
@@ -7932,7 +8005,7 @@ var SuspenseCache = (function () {
     SuspenseCache.prototype.getQueryRef = function (cacheKey, createObservable) {
         var ref = this.queryRefs.lookupArray(cacheKey);
         if (!ref.current) {
-            ref.current = new QueryReference(createObservable(), {
+            ref.current = new InternalQueryReference(createObservable(), {
                 key: cacheKey,
                 autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs,
                 onDispose: function () {
@@ -7945,7 +8018,7 @@ var SuspenseCache = (function () {
     return SuspenseCache;
 }());
 
-exports.setLogVerbosity = tsInvariant.setVerbosity;
+exports.setLogVerbosity = invariant$1.setVerbosity;
 exports.Observable = zenObservableTs.Observable;
 exports.disableExperimentalFragmentVariables = graphqlTag.disableExperimentalFragmentVariables;
 exports.disableFragmentWarnings = graphqlTag.disableFragmentWarnings;