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

package/README.md

@@ -21,13 +21,13 @@ Learn how to use Apollo Client with self-paced hands-on training on Odyssey, Apo
 
 ## Maintainers
 
-- [@benjamn](https://github.com/benjamn)
-- [@alessbell](https://github.com/alessbell)
-- [@bignimbus](https://github.com/bignimbus)
-- [@hwillson](https://github.com/hwillson)
-- [@jpvajda](https://github.com/jpvajda)
-- [@mrdoombringer](https://github.com/mrdoombringer)
-- [@jerelmiller](https://github.com/jerelmiller)
+|Name|Username|
+|---|---|
+|Ben Newman|[@benjamn](https://github.com/benjamn)|
+|Alessia Bellisario|[@alessbell](https://github.com/alessbell)|
+|Jeff Auriemma|[@bignimbus](https://github.com/bignimbus)|
+|Hugh Willson|[@hwillson](https://github.com/hwillson)|
+|Jerel Miller|[@jerelmiller](https://github.com/jerelmiller)|
 
 ## Who is Apollo?
 

package/apollo-client.cjs

@@ -1053,8 +1053,53 @@ function isNonEmptyArray(value) {
     return Array.isArray(value) && value.length > 0;
 }
 
+function isExecutionPatchIncrementalResult(value) {
+    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;
+}
+
 function graphQLResultHasError(result) {
-    return (result.errors && result.errors.length > 0) || false;
+    var errors = getGraphQLErrorsFromResult(result);
+    return isNonEmptyArray(errors);
+}
+function getGraphQLErrorsFromResult(result) {
+    var graphQLErrors = isNonEmptyArray(result.errors)
+        ? result.errors.slice(0)
+        : [];
+    if (isExecutionPatchIncrementalResult(result) &&
+        isNonEmptyArray(result.incremental)) {
+        result.incremental.forEach(function (incrementalResult) {
+            if (incrementalResult.errors) {
+                graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);
+            }
+        });
+    }
+    return graphQLErrors;
 }
 
 function compact() {
@@ -1300,7 +1345,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.8.0-alpha.0';
+var version = '3.8.0-alpha.1';
 
 function isNodeResponse(value) {
     return !!value.body;
@@ -1881,10 +1926,6 @@ var HttpLink = (function (_super) {
     return HttpLink;
 }(ApolloLink));
 
-function isExecutionPatchIncrementalResult(value) {
-    return !!value.incremental;
-}
-
 var ApolloCache = (function () {
     function ApolloCache() {
         this.getFragmentDoc = optimism.wrap(getFragmentQueryDocument);
@@ -4613,7 +4654,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 ||
@@ -4656,7 +4697,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);
@@ -5182,22 +5226,8 @@ var QueryInfo = (function () {
             : [];
         this.reset();
         if ('incremental' in result && 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();
@@ -5358,7 +5388,7 @@ var QueryManager = (function () {
                                 return asyncMap(self.getObservableFromLink(mutation, tslib.__assign(tslib.__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false), function (result) {
                                     if (graphQLResultHasError(result) && errorPolicy === 'none') {
                                         throw new ApolloError({
-                                            graphQLErrors: result.errors,
+                                            graphQLErrors: getGraphQLErrorsFromResult(result),
                                         });
                                     }
                                     if (mutationStoreValue) {
@@ -5392,7 +5422,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) {
@@ -5420,12 +5452,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) && 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) {
@@ -5472,6 +5525,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({
@@ -5481,16 +5536,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) {
@@ -5858,17 +5921,8 @@ var QueryManager = (function () {
         var requestId = queryInfo.lastRequestId = this.generateRequestId();
         var linkDocument = this.cache.transformForLink(this.transform(queryInfo.document).document);
         return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {
-            var graphQLErrors = isNonEmptyArray(result.errors)
-                ? result.errors.slice(0)
-                : [];
-            if ('incremental' in result && isNonEmptyArray(result.incremental)) {
-                result.incremental.forEach(function (incrementalResult) {
-                    if (incrementalResult.errors) {
-                        graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);
-                    }
-                });
-            }
-            var hasErrors = isNonEmptyArray(graphQLErrors);
+            var graphQLErrors = getGraphQLErrorsFromResult(result);
+            var hasErrors = graphQLErrors.length > 0;
             if (requestId >= queryInfo.lastRequestId) {
                 if (hasErrors && options.errorPolicy === "none") {
                     throw queryInfo.markError(new ApolloError({
@@ -7171,24 +7225,28 @@ function useSuspenseQuery_experimental(query, options) {
     var client = useApolloClient(options.client);
     var watchQueryOptions = useWatchQueryOptions({ query: query, options: options, client: client });
     var previousWatchQueryOptionsRef = React.useRef(watchQueryOptions);
+    var deferred = useIsDeferred(query);
     var fetchPolicy = watchQueryOptions.fetchPolicy, errorPolicy = watchQueryOptions.errorPolicy, returnPartialData = watchQueryOptions.returnPartialData, variables = watchQueryOptions.variables;
     var cacheEntry = suspenseCache.lookup(query, variables);
     var observable = React.useState(function () {
         return (cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.observable) || client.watchQuery(watchQueryOptions);
     })[0];
     var result = useObservableQueryResult(observable);
-    if (result.error && errorPolicy === 'none') {
+    var hasFullResult = result.data && !result.partial;
+    var hasPartialResult = result.data && result.partial;
+    var usePartialResult = returnPartialData && hasPartialResult;
+    if (result.error &&
+        errorPolicy === 'none' &&
+        (!deferred || !hasPartialResult)) {
         throw result.error;
     }
     if (result.loading) {
         if (!cacheEntry) {
             cacheEntry = suspenseCache.add(query, variables, {
-                promise: observable.reobserve(watchQueryOptions),
+                promise: maybeWrapConcastWithCustomPromise(observable.reobserveAsConcast(watchQueryOptions), { deferred: deferred }),
                 observable: observable,
             });
         }
-        var hasFullResult = result.data && !result.partial;
-        var usePartialResult = returnPartialData && result.partial && result.data;
         var hasUsableResult = usePartialResult ||
             (fetchPolicy === 'cache-and-network' && hasFullResult);
         if (!hasUsableResult && !cacheEntry.fulfilled) {
@@ -7215,7 +7273,7 @@ function useSuspenseQuery_experimental(query, options) {
     return React.useMemo(function () {
         return {
             data: result.data,
-            error: errorPolicy === 'all' ? toApolloError(result) : void 0,
+            error: errorPolicy === 'ignore' ? void 0 : toApolloError(result),
             fetchMore: function (options) {
                 var promise = observable.fetchMore(options);
                 suspenseCache.add(query, watchQueryOptions.variables, {
@@ -7254,6 +7312,21 @@ function toApolloError(result) {
         ? new ApolloError({ graphQLErrors: result.errors })
         : result.error;
 }
+function maybeWrapConcastWithCustomPromise(concast, _a) {
+    var deferred = _a.deferred;
+    if (deferred) {
+        return new Promise(function (resolve, reject) {
+            var subscription = concast.subscribe({
+                next: function (value) {
+                    resolve(value);
+                    subscription.unsubscribe();
+                },
+                error: reject,
+            });
+        });
+    }
+    return concast.promise;
+}
 function useWatchQueryOptions(_a) {
     var query = _a.query, options = _a.options, client = _a.client;
     var defaultOptions = client.defaultOptions.watchQuery;
@@ -7266,6 +7339,9 @@ function useWatchQueryOptions(_a) {
     }
     return watchQueryOptions;
 }
+function useIsDeferred(query) {
+    return React.useMemo(function () { return hasDirectives(['defer'], query); }, [query]);
+}
 function useObservableQueryResult(observable) {
     var resultRef = React.useRef();
     var isMountedRef = React.useRef(false);