@apollo/client 3.8.0-alpha.11 → 3.8.0-alpha.13

package/core/core.cjs

@@ -6,7 +6,7 @@ var globals = require('../utilities/globals');
 var tslib = require('tslib');
 var core = require('../link/core');
 var http = require('../link/http');
-var equality = require('@wry/equality');
+var equal = require('@wry/equality');
 var utilities = require('../utilities');
 var cache = require('../cache');
 var errors = require('../errors');
@@ -15,16 +15,20 @@ var utils = require('../link/utils');
 var tsInvariant = require('ts-invariant');
 var graphqlTag = require('graphql-tag');
 
-var version = '3.8.0-alpha.11';
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
 
-function isNonEmptyArray(value) {
-    return Array.isArray(value) && value.length > 0;
-}
+var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
+
+var version = '3.8.0-alpha.13';
 
 function isNonNullObject(obj) {
     return obj !== null && typeof obj === 'object';
 }
 
+function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+
 var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 var defaultReconciler = function (target, source, property) {
     return this.merge(target[property], source[property]);
@@ -116,6 +120,73 @@ exports.NetworkStatus = void 0;
 function isNetworkRequestInFlight(networkStatus) {
     return networkStatus ? networkStatus < 7 : false;
 }
+function isNetworkRequestSettled(networkStatus) {
+    return networkStatus === 7 || networkStatus === 8;
+}
+
+function equalByQuery(query, _a, _b, variables) {
+    var aData = _a.data, aRest = tslib.__rest(_a, ["data"]);
+    var bData = _b.data, bRest = tslib.__rest(_b, ["data"]);
+    return equal__default(aRest, bRest) && equalBySelectionSet(utilities.getMainDefinition(query).selectionSet, aData, bData, {
+        fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(query)),
+        variables: variables,
+    });
+}
+function equalBySelectionSet(selectionSet, aResult, bResult, context) {
+    if (aResult === bResult) {
+        return true;
+    }
+    var seenSelections = new Set();
+    return selectionSet.selections.every(function (selection) {
+        if (seenSelections.has(selection))
+            return true;
+        seenSelections.add(selection);
+        if (!utilities.shouldInclude(selection, context.variables))
+            return true;
+        if (selectionHasNonreactiveDirective(selection))
+            return true;
+        if (utilities.isField(selection)) {
+            var resultKey = utilities.resultKeyNameFromField(selection);
+            var aResultChild = aResult && aResult[resultKey];
+            var bResultChild = bResult && bResult[resultKey];
+            var childSelectionSet = selection.selectionSet;
+            if (!childSelectionSet) {
+                return equal__default(aResultChild, bResultChild);
+            }
+            var aChildIsArray = Array.isArray(aResultChild);
+            var bChildIsArray = Array.isArray(bResultChild);
+            if (aChildIsArray !== bChildIsArray)
+                return false;
+            if (aChildIsArray && bChildIsArray) {
+                var length_1 = aResultChild.length;
+                if (bResultChild.length !== length_1) {
+                    return false;
+                }
+                for (var i = 0; i < length_1; ++i) {
+                    if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);
+        }
+        else {
+            var fragment = utilities.getFragmentFromSelection(selection, context.fragmentMap);
+            if (fragment) {
+                if (selectionHasNonreactiveDirective(fragment))
+                    return true;
+                return equalBySelectionSet(fragment.selectionSet, aResult, bResult, context);
+            }
+        }
+    });
+}
+function selectionHasNonreactiveDirective(selection) {
+    return !!selection.directives && selection.directives.some(directiveIsNonreactive);
+}
+function directiveIsNonreactive(dir) {
+    return dir.name.value === "nonreactive";
+}
 
 var assign = Object.assign, hasOwnProperty$1 = Object.hasOwnProperty;
 var ObservableQuery = (function (_super) {
@@ -211,7 +282,7 @@ var ObservableQuery = (function (_super) {
             if (diff.complete || this.options.returnPartialData) {
                 result.data = diff.result;
             }
-            if (equality.equal(result.data, {})) {
+            if (equal.equal(result.data, {})) {
                 result.data = void 0;
             }
             if (diff.complete) {
@@ -242,15 +313,21 @@ var ObservableQuery = (function (_super) {
         return result;
     };
     ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {
-        return (!this.last ||
-            !equality.equal(this.last.result, newResult) ||
-            (variables && !equality.equal(this.last.variables, variables)));
+        if (!this.last) {
+            return true;
+        }
+        var query = this.options.query;
+        var resultIsDifferent = this.queryManager.transform(query).hasNonreactiveDirective
+            ? !equalByQuery(query, this.last.result, newResult, this.variables)
+            : !equal.equal(this.last.result, newResult);
+        return (resultIsDifferent ||
+            (variables && !equal.equal(this.last.variables, variables)));
     };
     ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {
         var last = this.last;
         if (last &&
             last[key] &&
-            (!variablesMustMatch || equality.equal(last.variables, this.variables))) {
+            (!variablesMustMatch || equal.equal(last.variables, this.variables))) {
             return last[key];
         }
     };
@@ -289,7 +366,7 @@ var ObservableQuery = (function (_super) {
                 globals.__DEV__ && globals.invariant.warn("Called refetch(".concat(JSON.stringify(variables), ") for query ").concat(((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || JSON.stringify(queryDef), ", which does not declare a $variables variable.\nDid you mean to call refetch(variables) instead of refetch({ variables })?"));
             }
         }
-        if (variables && !equality.equal(this.options.variables, variables)) {
+        if (variables && !equal.equal(this.options.variables, variables)) {
             reobserveOptions.variables = this.options.variables = tslib.__assign(tslib.__assign({}, this.options.variables), variables);
         }
         this.queryInfo.resetLastWrite();
@@ -384,7 +461,7 @@ var ObservableQuery = (function (_super) {
         return this.reobserve(newOptions);
     };
     ObservableQuery.prototype.setVariables = function (variables) {
-        if (equality.equal(this.variables, variables)) {
+        if (equal.equal(this.variables, variables)) {
             return this.observers.size
                 ? this.result()
                 : Promise.resolve();
@@ -449,7 +526,7 @@ var ObservableQuery = (function (_super) {
     };
     ObservableQuery.prototype.fetch = function (options, newNetworkStatus) {
         this.queryManager.setObservableQuery(this);
-        return this.queryManager.fetchQueryObservable(this.queryId, options, newNetworkStatus);
+        return this.queryManager['fetchConcastWithInfo'](this.queryId, options, newNetworkStatus);
     };
     ObservableQuery.prototype.updatePolling = function () {
         var _this = this;
@@ -494,15 +571,15 @@ var ObservableQuery = (function (_super) {
     };
     ObservableQuery.prototype.updateLastResult = function (newResult, variables) {
         if (variables === void 0) { variables = this.variables; }
-        this.last = tslib.__assign(tslib.__assign({}, this.last), { result: this.queryManager.assumeImmutableResults
-                ? newResult
-                : utilities.cloneDeep(newResult), variables: variables });
-        if (!utilities.isNonEmptyArray(newResult.errors)) {
-            delete this.last.error;
+        var error = this.getLastError();
+        if (error && this.last && !equal.equal(variables, this.last.variables)) {
+            error = void 0;
         }
-        return this.last;
+        return this.last = tslib.__assign({ result: this.queryManager.assumeImmutableResults
+                ? newResult
+                : utilities.cloneDeep(newResult), variables: variables }, (error ? { error: error } : null));
     };
-    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
+    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {
         var _this = this;
         this.isTornDown = false;
         var useDisposableConcast = newNetworkStatus === exports.NetworkStatus.refetch ||
@@ -518,7 +595,7 @@ var ObservableQuery = (function (_super) {
             this.updatePolling();
             if (newOptions &&
                 newOptions.variables &&
-                !equality.equal(newOptions.variables, oldVariables) &&
+                !equal.equal(newOptions.variables, oldVariables) &&
                 options.fetchPolicy !== "standby" &&
                 options.fetchPolicy === oldFetchPolicy) {
                 this.applyNextFetchPolicy("variables-changed", options);
@@ -528,7 +605,7 @@ var ObservableQuery = (function (_super) {
             }
         }
         var variables = options.variables && tslib.__assign({}, options.variables);
-        var concast = this.fetch(options, newNetworkStatus);
+        var _a = this.fetch(options, newNetworkStatus), concast = _a.concast, fromLink = _a.fromLink;
         var observer = {
             next: function (result) {
                 _this.reportResult(result, variables);
@@ -537,7 +614,7 @@ var ObservableQuery = (function (_super) {
                 _this.reportError(error, variables);
             },
         };
-        if (!useDisposableConcast) {
+        if (!useDisposableConcast && (fromLink || !this.concast)) {
             if (this.concast && this.observer) {
                 this.concast.removeObserver(this.observer);
             }
@@ -545,18 +622,22 @@ var ObservableQuery = (function (_super) {
             this.observer = observer;
         }
         concast.addObserver(observer);
-        return concast.promise;
+        return concast;
+    };
+    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
+        return this.reobserveAsConcast(newOptions, newNetworkStatus).promise;
     };
     ObservableQuery.prototype.observe = function () {
         this.reportResult(this.getCurrentResult(false), this.variables);
     };
     ObservableQuery.prototype.reportResult = function (result, variables) {
         var lastError = this.getLastError();
-        if (lastError || this.isDifferentFromLastResult(result, variables)) {
-            if (lastError || !result.partial || this.options.returnPartialData) {
-                this.updateLastResult(result, variables);
-            }
-            utilities.iterateObserversSafely(this.observers, 'next', result);
+        var isDifferent = this.isDifferentFromLastResult(result, variables);
+        if (lastError || !result.partial || this.options.returnPartialData) {
+            this.updateLastResult(result, variables);
+        }
+        if (lastError || isDifferent) {
+            utilities.iterateObserversSafely(this.observers, "next", result);
         }
     };
     ObservableQuery.prototype.reportError = function (error, variables) {
@@ -965,10 +1046,10 @@ var QueryInfo = (function () {
         var networkStatus = query.networkStatus || exports.NetworkStatus.loading;
         if (this.variables &&
             this.networkStatus !== exports.NetworkStatus.loading &&
-            !equality.equal(this.variables, query.variables)) {
+            !equal.equal(this.variables, query.variables)) {
             networkStatus = exports.NetworkStatus.setVariables;
         }
-        if (!equality.equal(query.variables, this.variables)) {
+        if (!equal.equal(query.variables, this.variables)) {
             this.lastDiff = void 0;
         }
         Object.assign(this, {
@@ -993,7 +1074,7 @@ var QueryInfo = (function () {
     QueryInfo.prototype.getDiff = function (variables) {
         if (variables === void 0) { variables = this.variables; }
         var options = this.getDiffOptions(variables);
-        if (this.lastDiff && equality.equal(options, this.lastDiff.options)) {
+        if (this.lastDiff && equal.equal(options, this.lastDiff.options)) {
             return this.lastDiff.diff;
         }
         this.updateWatch(this.variables = variables);
@@ -1027,7 +1108,7 @@ var QueryInfo = (function () {
         var oldDiff = this.lastDiff && this.lastDiff.diff;
         this.updateLastDiff(diff);
         if (!this.dirty &&
-            !equality.equal(oldDiff && oldDiff.result, diff && diff.result)) {
+            !equal.equal(oldDiff && oldDiff.result, diff && diff.result)) {
             this.dirty = true;
             if (!this.notifyTimeout) {
                 this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);
@@ -1102,7 +1183,7 @@ var QueryInfo = (function () {
         }
         var watchOptions = tslib.__assign(tslib.__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });
         if (!this.lastWatch ||
-            !equality.equal(watchOptions, this.lastWatch)) {
+            !equal.equal(watchOptions, this.lastWatch)) {
             this.cancel();
             this.cancel = this.cache.watch(this.lastWatch = watchOptions);
         }
@@ -1114,8 +1195,8 @@ var QueryInfo = (function () {
         var lastWrite = this.lastWrite;
         return !(lastWrite &&
             lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
-            equality.equal(variables, lastWrite.variables) &&
-            equality.equal(result.data, lastWrite.result.data));
+            equal.equal(variables, lastWrite.variables) &&
+            equal.equal(result.data, lastWrite.result.data));
     };
     QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {
         var _this = this;
@@ -1517,14 +1598,17 @@ var QueryManager = (function () {
         var _a = (this.defaultOptions.transformQuery || Object.create(null)).removeClientFields, removeClientFields = _a === void 0 ? true : _a;
         if (!transformCache.has(document)) {
             var transformed = this.cache.transformDocument(document);
-            var noConnection = utilities.removeConnectionDirectiveFromDocument(transformed);
+            var serverQuery = utilities.removeDirectivesFromDocument([
+                removeClientFields ? { name: 'client', remove: true } : {},
+                { name: 'connection' },
+                { name: 'nonreactive' },
+            ], transformed);
             var clientQuery = this.localState.clientQuery(transformed);
-            var serverQuery = noConnection &&
-                this.localState.serverQuery(noConnection, { removeClientFields: removeClientFields });
             var cacheEntry_1 = {
                 document: transformed,
                 hasClientExports: utilities.hasClientExports(transformed),
                 hasForcedResolvers: this.localState.shouldForceResolvers(transformed),
+                hasNonreactiveDirective: utilities.hasDirectives(['nonreactive'], transformed),
                 clientQuery: clientQuery,
                 serverQuery: serverQuery,
                 defaultVars: utilities.getDefaultValues(utilities.getOperationDefinition(transformed)),
@@ -1722,10 +1806,17 @@ var QueryManager = (function () {
                     }
                     _this.broadcastQueries();
                 }
-                if (utilities.graphQLResultHasError(result)) {
-                    throw new errors.ApolloError({
-                        graphQLErrors: result.errors,
-                    });
+                var hasErrors = utilities.graphQLResultHasError(result);
+                var hasProtocolErrors = errors.graphQLResultHasProtocolErrors(result);
+                if (hasErrors || hasProtocolErrors) {
+                    var errors$1 = {};
+                    if (hasErrors) {
+                        errors$1.graphQLErrors = result.errors;
+                    }
+                    if (hasProtocolErrors) {
+                        errors$1.protocolErrors = result.extensions[errors.PROTOCOL_ERRORS_SYMBOL];
+                    }
+                    throw new errors.ApolloError(errors$1);
                 }
                 return result;
             });
@@ -1857,6 +1948,9 @@ var QueryManager = (function () {
         });
     };
     QueryManager.prototype.fetchQueryObservable = function (queryId, options, networkStatus) {
+        return this.fetchConcastWithInfo(queryId, options, networkStatus).concast;
+    };
+    QueryManager.prototype.fetchConcastWithInfo = function (queryId, options, networkStatus) {
         var _this = this;
         if (networkStatus === void 0) { networkStatus = exports.NetworkStatus.loading; }
         var query = this.transform(options.query).document;
@@ -1875,24 +1969,36 @@ var QueryManager = (function () {
         });
         var fromVariables = function (variables) {
             normalized.variables = variables;
-            var concastSources = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
+            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
             if (normalized.fetchPolicy !== "standby" &&
-                concastSources.length > 0 &&
+                sourcesWithInfo.sources.length > 0 &&
                 queryInfo.observableQuery) {
                 queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
             }
-            return concastSources;
+            return sourcesWithInfo;
         };
         var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };
         this.fetchCancelFns.set(queryId, function (reason) {
             cleanupCancelFn();
             setTimeout(function () { return concast.cancel(reason); });
         });
-        var concast = new utilities.Concast(this.transform(normalized.query).hasClientExports
-            ? this.localState.addExportedVariables(normalized.query, normalized.variables, normalized.context).then(fromVariables)
-            : fromVariables(normalized.variables));
+        var concast, containsDataFromLink;
+        if (this.transform(normalized.query).hasClientExports) {
+            concast = new utilities.Concast(this.localState
+                .addExportedVariables(normalized.query, normalized.variables, normalized.context)
+                .then(fromVariables).then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));
+            containsDataFromLink = true;
+        }
+        else {
+            var sourcesWithInfo = fromVariables(normalized.variables);
+            containsDataFromLink = sourcesWithInfo.fromLink;
+            concast = new utilities.Concast(sourcesWithInfo.sources);
+        }
         concast.promise.then(cleanupCancelFn, cleanupCancelFn);
-        return concast;
+        return {
+            concast: concast,
+            fromLink: containsDataFromLink,
+        };
     };
     QueryManager.prototype.refetchQueries = function (_a) {
         var _this = this;
@@ -1977,7 +2083,7 @@ var QueryManager = (function () {
             var data = diff.result;
             if (globals.__DEV__ &&
                 !returnPartialData &&
-                !equality.equal(data, {})) {
+                !equal.equal(data, {})) {
                 logMissingFieldErrors(diff.missing);
             }
             var fromData = function (data) { return utilities.Observable.of(tslib.__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true }))); };
@@ -2016,54 +2122,40 @@ var QueryManager = (function () {
             case "cache-first": {
                 var diff = readCache();
                 if (diff.complete) {
-                    return [
-                        resultsFromCache(diff, queryInfo.markReady()),
-                    ];
+                    return { fromLink: false, sources: [resultsFromCache(diff, queryInfo.markReady())] };
                 }
                 if (returnPartialData || shouldNotify) {
-                    return [
-                        resultsFromCache(diff),
-                        resultsFromLink(),
-                    ];
+                    return { fromLink: true, sources: [resultsFromCache(diff), resultsFromLink()] };
                 }
-                return [
-                    resultsFromLink(),
-                ];
+                return { fromLink: true, sources: [resultsFromLink()] };
             }
             case "cache-and-network": {
                 var diff = readCache();
                 if (diff.complete || returnPartialData || shouldNotify) {
-                    return [
-                        resultsFromCache(diff),
-                        resultsFromLink(),
-                    ];
+                    return { fromLink: true, sources: [resultsFromCache(diff), resultsFromLink()] };
                 }
-                return [
-                    resultsFromLink(),
-                ];
+                return { fromLink: true, sources: [resultsFromLink()] };
             }
             case "cache-only":
-                return [
-                    resultsFromCache(readCache(), queryInfo.markReady()),
-                ];
+                return { fromLink: false, sources: [resultsFromCache(readCache(), queryInfo.markReady())] };
             case "network-only":
                 if (shouldNotify) {
-                    return [
-                        resultsFromCache(readCache()),
-                        resultsFromLink(),
-                    ];
+                    return { fromLink: true, sources: [resultsFromCache(readCache()), resultsFromLink()] };
                 }
-                return [resultsFromLink()];
+                return { fromLink: true, sources: [resultsFromLink()] };
             case "no-cache":
                 if (shouldNotify) {
-                    return [
-                        resultsFromCache(queryInfo.getDiff()),
-                        resultsFromLink(),
-                    ];
+                    return {
+                        fromLink: true,
+                        sources: [
+                            resultsFromCache(queryInfo.getDiff()),
+                            resultsFromLink(),
+                        ],
+                    };
                 }
-                return [resultsFromLink()];
+                return { fromLink: true, sources: [resultsFromLink()] };
             case "standby":
-                return [];
+                return { fromLink: false, sources: [] };
         }
     };
     QueryManager.prototype.getQuery = function (queryId) {
@@ -2342,6 +2434,7 @@ exports.gql = graphqlTag.gql;
 exports.resetCaches = graphqlTag.resetCaches;
 exports.ApolloClient = ApolloClient;
 exports.ObservableQuery = ObservableQuery;
+exports.isNetworkRequestSettled = isNetworkRequestSettled;
 for (var k in core) {
     if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = core[k];
 }