@apollo/client 3.8.0-alpha.0 → 3.8.0-alpha.1

package/core/core.cjs

@@ -15,10 +15,99 @@ var utils = require('../link/utils');
 var tsInvariant = require('ts-invariant');
 var graphqlTag = require('graphql-tag');
 
-var version = '3.8.0-alpha.0';
+var version = '3.8.0-alpha.1';
+
+function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+
+function isNonNullObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+
+var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+var defaultReconciler = function (target, source, property) {
+    return this.merge(target[property], source[property]);
+};
+var DeepMerger = (function () {
+    function DeepMerger(reconciler) {
+        if (reconciler === void 0) { reconciler = defaultReconciler; }
+        this.reconciler = reconciler;
+        this.isObject = isNonNullObject;
+        this.pastCopies = new Set();
+    }
+    DeepMerger.prototype.merge = function (target, source) {
+        var _this = this;
+        var context = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            context[_i - 2] = arguments[_i];
+        }
+        if (isNonNullObject(source) && isNonNullObject(target)) {
+            Object.keys(source).forEach(function (sourceKey) {
+                if (hasOwnProperty$2.call(target, sourceKey)) {
+                    var targetValue = target[sourceKey];
+                    if (source[sourceKey] !== targetValue) {
+                        var result = _this.reconciler.apply(_this, tslib.__spreadArray([target, source, sourceKey], context, false));
+                        if (result !== targetValue) {
+                            target = _this.shallowCopyForMerge(target);
+                            target[sourceKey] = result;
+                        }
+                    }
+                }
+                else {
+                    target = _this.shallowCopyForMerge(target);
+                    target[sourceKey] = source[sourceKey];
+                }
+            });
+            return target;
+        }
+        return source;
+    };
+    DeepMerger.prototype.shallowCopyForMerge = function (value) {
+        if (isNonNullObject(value)) {
+            if (!this.pastCopies.has(value)) {
+                if (Array.isArray(value)) {
+                    value = value.slice(0);
+                }
+                else {
+                    value = tslib.__assign({ __proto__: Object.getPrototypeOf(value) }, value);
+                }
+                this.pastCopies.add(value);
+            }
+        }
+        return value;
+    };
+    return DeepMerger;
+}());
 
 function isExecutionPatchIncrementalResult(value) {
-    return !!value.incremental;
+    return "incremental" in value;
+}
+function isExecutionPatchInitialResult(value) {
+    return "hasNext" in value && "data" in value;
+}
+function isExecutionPatchResult(value) {
+    return (isExecutionPatchIncrementalResult(value) ||
+        isExecutionPatchInitialResult(value));
+}
+function mergeIncrementalData(prevResult, result) {
+    var mergedData = prevResult;
+    var merger = new DeepMerger();
+    if (isExecutionPatchIncrementalResult(result) &&
+        isNonEmptyArray(result.incremental)) {
+        result.incremental.forEach(function (_a) {
+            var data = _a.data, path = _a.path;
+            for (var i = path.length - 1; i >= 0; --i) {
+                var key = path[i];
+                var isNumericKey = !isNaN(+key);
+                var parent_1 = isNumericKey ? [] : {};
+                parent_1[key] = data;
+                data = parent_1;
+            }
+            mergedData = merger.merge(mergedData, data);
+        });
+    }
+    return mergedData;
 }
 
 exports.NetworkStatus = void 0;
@@ -421,7 +510,7 @@ var ObservableQuery = (function (_super) {
         }
         return this.last;
     };
-    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
+    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {
         var _this = this;
         this.isTornDown = false;
         var useDisposableConcast = newNetworkStatus === exports.NetworkStatus.refetch ||
@@ -464,7 +553,10 @@ 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);
@@ -990,22 +1082,8 @@ var QueryInfo = (function () {
             : [];
         this.reset();
         if ('incremental' in result && utilities.isNonEmptyArray(result.incremental)) {
-            var mergedData_1 = this.getDiff().result;
-            result.incremental.forEach(function (_a) {
-                var data = _a.data, path = _a.path, errors = _a.errors;
-                for (var i = path.length - 1; i >= 0; --i) {
-                    var key = path[i];
-                    var isNumericKey = !isNaN(+key);
-                    var parent_1 = isNumericKey ? [] : {};
-                    parent_1[key] = data;
-                    data = parent_1;
-                }
-                if (errors) {
-                    graphQLErrors.push.apply(graphQLErrors, errors);
-                }
-                mergedData_1 = merger.merge(mergedData_1, data);
-            });
-            result.data = mergedData_1;
+            var mergedData = mergeIncrementalData(this.getDiff().result, result);
+            result.data = mergedData;
         }
         else if ('hasNext' in result && result.hasNext) {
             var diff = this.getDiff();
@@ -1166,7 +1244,7 @@ var QueryManager = (function () {
                                 return utilities.asyncMap(self.getObservableFromLink(mutation, tslib.__assign(tslib.__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false), function (result) {
                                     if (utilities.graphQLResultHasError(result) && errorPolicy === 'none') {
                                         throw new errors.ApolloError({
-                                            graphQLErrors: result.errors,
+                                            graphQLErrors: utilities.getGraphQLErrorsFromResult(result),
                                         });
                                     }
                                     if (mutationStoreValue) {
@@ -1200,7 +1278,9 @@ var QueryManager = (function () {
                                 }).subscribe({
                                     next: function (storeResult) {
                                         self.broadcastQueries();
-                                        resolve(storeResult);
+                                        if (!('hasNext' in storeResult) || storeResult.hasNext === false) {
+                                            resolve(storeResult);
+                                        }
                                     },
                                     error: function (err) {
                                         if (mutationStoreValue) {
@@ -1228,12 +1308,33 @@ var QueryManager = (function () {
         var cacheWrites = [];
         var skipCache = mutation.fetchPolicy === "no-cache";
         if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
-            cacheWrites.push({
-                result: result.data,
-                dataId: 'ROOT_MUTATION',
-                query: mutation.document,
-                variables: mutation.variables,
-            });
+            if (!isExecutionPatchIncrementalResult(result)) {
+                cacheWrites.push({
+                    result: result.data,
+                    dataId: 'ROOT_MUTATION',
+                    query: mutation.document,
+                    variables: mutation.variables,
+                });
+            }
+            if (isExecutionPatchIncrementalResult(result) && utilities.isNonEmptyArray(result.incremental)) {
+                var diff = cache.diff({
+                    id: "ROOT_MUTATION",
+                    query: this.transform(mutation.document).asQuery,
+                    variables: mutation.variables,
+                    optimistic: false,
+                    returnPartialData: true,
+                });
+                var mergedData = mergeIncrementalData(diff.result, result);
+                if (typeof mergedData !== 'undefined') {
+                    result.data = mergedData;
+                    cacheWrites.push({
+                        result: mergedData,
+                        dataId: 'ROOT_MUTATION',
+                        query: mutation.document,
+                        variables: mutation.variables,
+                    });
+                }
+            }
             var updateQueries_1 = mutation.updateQueries;
             if (updateQueries_1) {
                 this.queries.forEach(function (_a, queryId) {
@@ -1280,6 +1381,8 @@ var QueryManager = (function () {
                         cacheWrites.forEach(function (write) { return cache.write(write); });
                     }
                     var update = mutation.update;
+                    var isFinalResult = !isExecutionPatchResult(result) ||
+                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);
                     if (update) {
                         if (!skipCache) {
                             var diff = cache.diff({
@@ -1289,16 +1392,24 @@ var QueryManager = (function () {
                                 optimistic: false,
                                 returnPartialData: true,
                             });
-                            if (diff.complete && !(isExecutionPatchIncrementalResult(result))) {
+                            if (diff.complete) {
                                 result = tslib.__assign(tslib.__assign({}, result), { data: diff.result });
+                                if ('incremental' in result) {
+                                    delete result.incremental;
+                                }
+                                if ('hasNext' in result) {
+                                    delete result.hasNext;
+                                }
                             }
                         }
-                        update(cache, result, {
-                            context: mutation.context,
-                            variables: mutation.variables,
-                        });
+                        if (isFinalResult) {
+                            update(cache, result, {
+                                context: mutation.context,
+                                variables: mutation.variables,
+                            });
+                        }
                     }
-                    if (!skipCache && !mutation.keepRootFields) {
+                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {
                         cache.modify({
                             id: 'ROOT_MUTATION',
                             fields: function (value, _a) {
@@ -1666,17 +1777,8 @@ var QueryManager = (function () {
         var requestId = queryInfo.lastRequestId = this.generateRequestId();
         var linkDocument = this.cache.transformForLink(this.transform(queryInfo.document).document);
         return utilities.asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {
-            var graphQLErrors = utilities.isNonEmptyArray(result.errors)
-                ? result.errors.slice(0)
-                : [];
-            if ('incremental' in result && utilities.isNonEmptyArray(result.incremental)) {
-                result.incremental.forEach(function (incrementalResult) {
-                    if (incrementalResult.errors) {
-                        graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);
-                    }
-                });
-            }
-            var hasErrors = utilities.isNonEmptyArray(graphQLErrors);
+            var graphQLErrors = utilities.getGraphQLErrorsFromResult(result);
+            var hasErrors = graphQLErrors.length > 0;
             if (requestId >= queryInfo.lastRequestId) {
                 if (hasErrors && options.errorPolicy === "none") {
                     throw queryInfo.markError(new errors.ApolloError({