@apollo/client 3.7.0-beta.6 → 3.7.0-beta.7

package/README.md

@@ -23,8 +23,10 @@ Learn how to use Apollo Client with self-paced hands-on training on Odyssey, Apo
 
 - [@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)
 
 ## Who is Apollo?
 

package/apollo-client.cjs

@@ -53,17 +53,17 @@ function shouldInclude(_a, variables) {
         return directive.name.value === 'skip' ? !evaledValue : evaledValue;
     });
 }
-function getDirectiveNames(root) {
-    var names = [];
+function hasDirectives(names, root) {
+    var nameSet = new Set(names);
+    var nameCount = nameSet.size;
     graphql.visit(root, {
         Directive: function (node) {
-            names.push(node.name.value);
+            if (nameSet.delete(node.name.value)) {
+                return graphql.BREAK;
+            }
         },
     });
-    return names;
-}
-function hasDirectives(names, root) {
-    return getDirectiveNames(root).some(function (name) { return names.indexOf(name) > -1; });
+    return nameSet.size < nameCount;
 }
 function hasClientExports(document) {
     return (document &&
@@ -900,6 +900,7 @@ var canUseWeakMap = typeof WeakMap === 'function' &&
 var canUseWeakSet = typeof WeakSet === 'function';
 var canUseSymbol = typeof Symbol === 'function' &&
     typeof Symbol.for === 'function';
+var canUseAsyncIteratorSymbol = canUseSymbol && Symbol.asyncIterator;
 var canUseDOM = typeof maybe(function () { return window.document.createElement; }) === "function";
 var usingJSDOM = maybe(function () { return navigator.userAgent.indexOf("jsdom") >= 0; }) || false;
 var canUseLayoutEffect = canUseDOM && !usingJSDOM;
@@ -1298,38 +1299,303 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.7.0-beta.6';
+var version = '3.7.0-beta.7';
 
-var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
-function parseAndCheckHttpResponse(operations) {
-    return function (response) { return response
-        .text()
-        .then(function (bodyText) {
-        try {
-            return JSON.parse(bodyText);
+function isNodeResponse(value) {
+    return !!value.body;
+}
+function isReadableStream(value) {
+    return !!value.getReader;
+}
+function isAsyncIterableIterator(value) {
+    return !!(canUseAsyncIteratorSymbol &&
+        value[Symbol.asyncIterator]);
+}
+function isStreamableBlob(value) {
+    return !!value.stream;
+}
+function isBlob(value) {
+    return !!value.arrayBuffer;
+}
+function isNodeReadableStream(value) {
+    return !!value.pipe;
+}
+
+function asyncIterator(source) {
+    var _a;
+    var iterator = source[Symbol.asyncIterator]();
+    return _a = {
+            next: function () {
+                return iterator.next();
+            }
+        },
+        _a[Symbol.asyncIterator] = function () {
+            return this;
+        },
+        _a;
+}
+
+function nodeStreamIterator(stream) {
+    var cleanup = null;
+    var error = null;
+    var done = false;
+    var data = [];
+    var waiting = [];
+    function onData(chunk) {
+        if (error)
+            return;
+        if (waiting.length) {
+            var shiftedArr = waiting.shift();
+            if (Array.isArray(shiftedArr) && shiftedArr[0]) {
+                return shiftedArr[0]({ value: chunk, done: false });
+            }
         }
-        catch (err) {
-            var parseError = err;
-            parseError.name = 'ServerParseError';
-            parseError.response = response;
-            parseError.statusCode = response.status;
-            parseError.bodyText = bodyText;
-            throw parseError;
+        data.push(chunk);
+    }
+    function onError(err) {
+        error = err;
+        var all = waiting.slice();
+        all.forEach(function (pair) {
+            pair[1](err);
+        });
+        !cleanup || cleanup();
+    }
+    function onEnd() {
+        done = true;
+        var all = waiting.slice();
+        all.forEach(function (pair) {
+            pair[0]({ value: undefined, done: true });
+        });
+        !cleanup || cleanup();
+    }
+    cleanup = function () {
+        cleanup = null;
+        stream.removeListener("data", onData);
+        stream.removeListener("error", onError);
+        stream.removeListener("end", onEnd);
+        stream.removeListener("finish", onEnd);
+        stream.removeListener("close", onEnd);
+    };
+    stream.on("data", onData);
+    stream.on("error", onError);
+    stream.on("end", onEnd);
+    stream.on("finish", onEnd);
+    stream.on("close", onEnd);
+    function getNext() {
+        return new Promise(function (resolve, reject) {
+            if (error)
+                return reject(error);
+            if (data.length)
+                return resolve({ value: data.shift(), done: false });
+            if (done)
+                return resolve({ value: undefined, done: true });
+            waiting.push([resolve, reject]);
+        });
+    }
+    var iterator = {
+        next: function () {
+            return getNext();
+        },
+    };
+    if (canUseAsyncIteratorSymbol) {
+        iterator[Symbol.asyncIterator] = function () {
+            return this;
+        };
+    }
+    return iterator;
+}
+
+function promiseIterator(promise) {
+    var resolved = false;
+    var iterator = {
+        next: function () {
+            if (resolved)
+                return Promise.resolve({
+                    value: undefined,
+                    done: true,
+                });
+            resolved = true;
+            return new Promise(function (resolve, reject) {
+                promise
+                    .then(function (value) {
+                    resolve({ value: value, done: false });
+                })
+                    .catch(reject);
+            });
+        },
+    };
+    if (canUseAsyncIteratorSymbol) {
+        iterator[Symbol.asyncIterator] = function () {
+            return this;
+        };
+    }
+    return iterator;
+}
+
+function readerIterator(reader) {
+    var iterator = {
+        next: function () {
+            return reader.read();
+        },
+    };
+    if (canUseAsyncIteratorSymbol) {
+        iterator[Symbol.asyncIterator] = function () {
+            return this;
+        };
+    }
+    return iterator;
+}
+
+function responseIterator(response) {
+    var body = response;
+    if (isNodeResponse(response))
+        body = response.body;
+    if (isAsyncIterableIterator(body))
+        return asyncIterator(body);
+    if (isReadableStream(body))
+        return readerIterator(body.getReader());
+    if (isStreamableBlob(body)) {
+        return readerIterator(body.stream().getReader());
+    }
+    if (isBlob(body))
+        return promiseIterator(body.arrayBuffer());
+    if (isNodeReadableStream(body))
+        return nodeStreamIterator(body);
+    throw new Error("Unknown body type for responseIterator. Please pass a streamable response.");
+}
+
+var hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+function readMultipartBody(response, observer) {
+    var _a, _b, _c;
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _d, value, done, chunk, bi, message, i, headers, contentType_1, body, result;
+        var _e;
+        return tslib.__generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    if (TextDecoder === undefined) {
+                        throw new Error("TextDecoder must be defined in the environment: please import a polyfill.");
+                    }
+                    decoder = new TextDecoder("utf-8");
+                    contentType = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get('content-type');
+                    delimiter = "boundary=";
+                    boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter))
+                        ? contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['"]/g, "").replace(/\;(.*)/gm, "").trim()
+                        : "-";
+                    boundary = "--".concat(boundaryVal);
+                    buffer = "";
+                    iterator = responseIterator(response);
+                    running = true;
+                    _f.label = 1;
+                case 1:
+                    if (!running) return [3, 3];
+                    return [4, iterator.next()];
+                case 2:
+                    _d = _f.sent(), value = _d.value, done = _d.done;
+                    chunk = typeof value === "string" ? value : decoder.decode(value);
+                    running = !done;
+                    buffer += chunk;
+                    bi = buffer.indexOf(boundary);
+                    while (bi > -1) {
+                        message = void 0;
+                        _e = [
+                            buffer.slice(0, bi),
+                            buffer.slice(bi + boundary.length),
+                        ], message = _e[0], buffer = _e[1];
+                        if (message.trim()) {
+                            i = message.indexOf("\r\n\r\n");
+                            headers = parseHeaders(message.slice(0, i));
+                            contentType_1 = headers["content-type"];
+                            if (contentType_1 &&
+                                contentType_1.toLowerCase().indexOf("application/json") === -1) {
+                                throw new Error("Unsupported patch content type: application/json is required.");
+                            }
+                            body = message.slice(i);
+                            try {
+                                result = parseJsonBody(response, body.replace("\r\n", ""));
+                                if (Object.keys(result).length > 1 ||
+                                    "data" in result ||
+                                    "incremental" in result ||
+                                    "errors" in result) {
+                                    (_b = observer.next) === null || _b === void 0 ? void 0 : _b.call(observer, result);
+                                }
+                            }
+                            catch (err) {
+                                handleError(err, observer);
+                            }
+                        }
+                        bi = buffer.indexOf(boundary);
+                    }
+                    return [3, 1];
+                case 3:
+                    (_c = observer.complete) === null || _c === void 0 ? void 0 : _c.call(observer);
+                    return [2];
+            }
+        });
+    });
+}
+function parseHeaders(headerText) {
+    var headersInit = {};
+    headerText.split("\n").forEach(function (line) {
+        var i = line.indexOf(":");
+        if (i > -1) {
+            var name_1 = line.slice(0, i).trim().toLowerCase();
+            var value = line.slice(i + 1).trim();
+            headersInit[name_1] = value;
         }
-    })
+    });
+    return headersInit;
+}
+function parseJsonBody(response, bodyText) {
+    try {
+        return JSON.parse(bodyText);
+    }
+    catch (err) {
+        var parseError = err;
+        parseError.name = "ServerParseError";
+        parseError.response = response;
+        parseError.statusCode = response.status;
+        parseError.bodyText = bodyText;
+        throw parseError;
+    }
+}
+function handleError(err, observer) {
+    var _a, _b;
+    if (err.name === "AbortError")
+        return;
+    if (err.result && err.result.errors && err.result.data) {
+        (_a = observer.next) === null || _a === void 0 ? void 0 : _a.call(observer, err.result);
+    }
+    (_b = observer.error) === null || _b === void 0 ? void 0 : _b.call(observer, err);
+}
+function readJsonBody(response, operation, observer) {
+    parseAndCheckHttpResponse(operation)(response)
         .then(function (result) {
-        if (response.status >= 300) {
-            throwServerError(response, result, "Response not successful: Received status code ".concat(response.status));
-        }
-        if (!Array.isArray(result) &&
-            !hasOwnProperty$3.call(result, 'data') &&
-            !hasOwnProperty$3.call(result, 'errors')) {
-            throwServerError(response, result, "Server response was missing for query '".concat(Array.isArray(operations)
-                ? operations.map(function (op) { return op.operationName; })
-                : operations.operationName, "'."));
-        }
-        return result;
-    }); };
+        var _a, _b;
+        (_a = observer.next) === null || _a === void 0 ? void 0 : _a.call(observer, result);
+        (_b = observer.complete) === null || _b === void 0 ? void 0 : _b.call(observer);
+    })
+        .catch(function (err) { return handleError(err, observer); });
+}
+function parseAndCheckHttpResponse(operations) {
+    return function (response) {
+        return response
+            .text()
+            .then(function (bodyText) { return parseJsonBody(response, bodyText); })
+            .then(function (result) {
+            if (response.status >= 300) {
+                throwServerError(response, result, "Response not successful: Received status code ".concat(response.status));
+            }
+            if (!Array.isArray(result) &&
+                !hasOwnProperty$3.call(result, "data") &&
+                !hasOwnProperty$3.call(result, "errors")) {
+                throwServerError(response, result, "Server response was missing for query '".concat(Array.isArray(operations)
+                    ? operations.map(function (op) { return op.operationName; })
+                    : operations.operationName, "'."));
+            }
+            return result;
+        });
+    };
 }
 
 var serializeFetchParameter = function (p, label) {
@@ -1541,6 +1807,9 @@ var createHttpLink = function (linkOptions) {
             !operation.query.definitions.some(definitionIsMutation)) {
             options.method = 'GET';
         }
+        if (hasDirectives(['defer'], operation.query)) {
+            options.headers.accept = "multipart/mixed; deferSpec=20220824, application/json";
+        }
         if (options.method === 'GET') {
             var _d = rewriteURIForGET(chosenURI, body), newURI = _d.newURI, parseError = _d.parseError;
             if (parseError) {
@@ -1560,23 +1829,17 @@ var createHttpLink = function (linkOptions) {
             var currentFetch = preferredFetch || maybe(function () { return fetch; }) || backupFetch;
             currentFetch(chosenURI, options)
                 .then(function (response) {
+                var _a;
                 operation.setContext({ response: response });
-                return response;
-            })
-                .then(parseAndCheckHttpResponse(operation))
-                .then(function (result) {
-                observer.next(result);
-                observer.complete();
-                return result;
-            })
-                .catch(function (err) {
-                if (err.name === 'AbortError')
-                    return;
-                if (err.result && err.result.errors && err.result.data) {
-                    observer.next(err.result);
+                var ctype = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get('content-type');
+                if (ctype !== null && /^multipart\/mixed/i.test(ctype)) {
+                    return readMultipartBody(response, observer);
                 }
-                observer.error(err);
-            });
+                else {
+                    return readJsonBody(response, operation, observer);
+                }
+            })
+                .catch(function (err) { return handleError(err, observer); });
             return function () {
                 if (controller)
                     controller.abort();
@@ -1596,6 +1859,10 @@ var HttpLink = (function (_super) {
     return HttpLink;
 }(ApolloLink));
 
+function isExecutionPatchIncrementalResult(value) {
+    return !!value.incremental;
+}
+
 var ApolloCache = (function () {
     function ApolloCache() {
         this.getFragmentDoc = optimism.wrap(getFragmentQueryDocument);
@@ -1680,25 +1947,29 @@ exports.Cache = void 0;
 (function (Cache) {
 })(exports.Cache || (exports.Cache = {}));
 
-var MissingFieldError = (function () {
+var MissingFieldError = (function (_super) {
+    tslib.__extends(MissingFieldError, _super);
     function MissingFieldError(message, path, query, variables) {
         var _a;
-        this.message = message;
-        this.path = path;
-        this.query = query;
-        this.variables = variables;
-        if (Array.isArray(this.path)) {
-            this.missing = this.message;
-            for (var i = this.path.length - 1; i >= 0; --i) {
-                this.missing = (_a = {}, _a[this.path[i]] = this.missing, _a);
+        var _this = _super.call(this, message) || this;
+        _this.message = message;
+        _this.path = path;
+        _this.query = query;
+        _this.variables = variables;
+        if (Array.isArray(_this.path)) {
+            _this.missing = _this.message;
+            for (var i = _this.path.length - 1; i >= 0; --i) {
+                _this.missing = (_a = {}, _a[_this.path[i]] = _this.missing, _a);
             }
         }
         else {
-            this.missing = this.path;
+            _this.missing = _this.path;
         }
+        _this.__proto__ = MissingFieldError.prototype;
+        return _this;
     }
     return MissingFieldError;
-}());
+}(Error));
 
 var hasOwn = Object.prototype.hasOwnProperty;
 function defaultDataIdFromObject(_a, context) {
@@ -4277,7 +4548,7 @@ var ObservableQuery = (function (_super) {
             if (_this.pollingInfo) {
                 if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus)) {
                     _this.reobserve({
-                        fetchPolicy: "network-only",
+                        fetchPolicy: _this.options.initialFetchPolicy === 'no-cache' ? 'no-cache' : 'network-only',
                     }, exports.NetworkStatus.poll).then(poll, poll);
                 }
                 else {
@@ -4736,7 +5007,6 @@ var QueryInfo = (function () {
     };
     QueryInfo.prototype.reset = function () {
         cancelNotifyTimeout(this);
-        this.lastDiff = void 0;
         this.dirty = false;
     };
     QueryInfo.prototype.getDiff = function (variables) {
@@ -4868,8 +5138,30 @@ var QueryInfo = (function () {
     };
     QueryInfo.prototype.markResult = function (result, options, cacheWriteBehavior) {
         var _this = this;
-        this.graphQLErrors = isNonEmptyArray(result.errors) ? result.errors : [];
+        var graphQLErrors = isNonEmptyArray(result.errors)
+            ? result.errors.slice(0)
+            : [];
         this.reset();
+        if ('incremental' in result && isNonEmptyArray(result.incremental)) {
+            var mergedData_1 = this.getDiff().result;
+            var merger_1 = new DeepMerger();
+            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_1.merge(mergedData_1, data);
+            });
+            result.data = mergedData_1;
+        }
+        this.graphQLErrors = graphQLErrors;
         if (options.fetchPolicy === 'no-cache') {
             this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));
         }
@@ -5146,7 +5438,7 @@ var QueryManager = (function () {
                                 optimistic: false,
                                 returnPartialData: true,
                             });
-                            if (diff.complete) {
+                            if (diff.complete && !(isExecutionPatchIncrementalResult(result))) {
                                 result = tslib.__assign(tslib.__assign({}, result), { data: diff.result });
                             }
                         }
@@ -5523,11 +5815,21 @@ var QueryManager = (function () {
         var requestId = queryInfo.lastRequestId = this.generateRequestId();
         options = cloneDeep(options);
         return asyncMap(this.getObservableFromLink(queryInfo.document, options.context, options.variables), function (result) {
-            var hasErrors = isNonEmptyArray(result.errors);
+            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);
             if (requestId >= queryInfo.lastRequestId) {
                 if (hasErrors && options.errorPolicy === "none") {
                     throw queryInfo.markError(new ApolloError({
-                        graphQLErrors: result.errors,
+                        graphQLErrors: graphQLErrors,
                     }));
                 }
                 queryInfo.markResult(result, options, cacheWriteBehavior);
@@ -5539,7 +5841,7 @@ var QueryManager = (function () {
                 networkStatus: exports.NetworkStatus.ready,
             };
             if (hasErrors && options.errorPolicy !== "ignore") {
-                aqr.errors = result.errors;
+                aqr.errors = graphQLErrors;
                 aqr.networkStatus = exports.NetworkStatus.error;
             }
             return aqr;
@@ -6538,7 +6840,7 @@ function useMutation(mutation, options) {
         if (executeOptions === void 0) { executeOptions = {}; }
         var _a = ref.current, client = _a.client, options = _a.options, mutation = _a.mutation;
         var baseOptions = tslib.__assign(tslib.__assign({}, options), { mutation: mutation });
-        if (!ref.current.result.loading && !baseOptions.ignoreResults) {
+        if (!ref.current.result.loading && !baseOptions.ignoreResults && ref.current.isMounted) {
             setResult(ref.current.result = {
                 loading: true,
                 error: void 0,
@@ -6568,8 +6870,8 @@ function useMutation(mutation, options) {
                     setResult(ref.current.result = result_1);
                 }
             }
-            (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onCompleted) === null || _b === void 0 ? void 0 : _b.call(_a, response.data);
-            (_c = executeOptions.onCompleted) === null || _c === void 0 ? void 0 : _c.call(executeOptions, response.data);
+            (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onCompleted) === null || _b === void 0 ? void 0 : _b.call(_a, response.data, clientOptions);
+            (_c = executeOptions.onCompleted) === null || _c === void 0 ? void 0 : _c.call(executeOptions, response.data, clientOptions);
             return response;
         }).catch(function (error) {
             var _a, _b, _c, _d;
@@ -6587,15 +6889,17 @@ function useMutation(mutation, options) {
                 }
             }
             if (((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) || clientOptions.onError) {
-                (_c = (_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onError) === null || _c === void 0 ? void 0 : _c.call(_b, error);
-                (_d = executeOptions.onError) === null || _d === void 0 ? void 0 : _d.call(executeOptions, error);
+                (_c = (_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onError) === null || _c === void 0 ? void 0 : _c.call(_b, error, clientOptions);
+                (_d = executeOptions.onError) === null || _d === void 0 ? void 0 : _d.call(executeOptions, error, clientOptions);
                 return { data: void 0, errors: error };
             }
             throw error;
         });
     }, []);
     var reset = React.useCallback(function () {
-        setResult({ called: false, loading: false, client: client });
+        if (ref.current.isMounted) {
+            setResult({ called: false, loading: false, client: client });
+        }
     }, []);
     React.useEffect(function () {
         ref.current.isMounted = true;
@@ -6728,7 +7032,7 @@ function useReactiveVar(rv) {
     return value;
 }
 
-function useFragment(options) {
+function useFragment_experimental(options) {
     var cache = useApolloClient().cache;
     var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, rest = tslib.__rest(options, ["fragment", "fragmentName", "from", "optimistic"]);
     var diffOptions = tslib.__assign(tslib.__assign({}, rest), { id: typeof from === "string" ? from : cache.identify(from), query: cache["getFragmentDoc"](fragment, fragmentName), optimistic: optimistic });
@@ -6744,8 +7048,11 @@ function useFragment(options) {
                 immediate = false;
             } }));
     }, function () {
-        return resultRef.current ||
-            (resultRef.current = diffToResult(latestDiff));
+        var latestDiffToResult = diffToResult(latestDiff);
+        return resultRef.current &&
+            equality.equal(resultRef.current.data, latestDiffToResult.data)
+            ? resultRef.current
+            : (resultRef.current = latestDiffToResult);
     });
 }
 function diffToResult(diff) {
@@ -6807,7 +7114,7 @@ exports.split = split;
 exports.throwServerError = throwServerError;
 exports.toPromise = toPromise;
 exports.useApolloClient = useApolloClient;
-exports.useFragment = useFragment;
+exports.useFragment_experimental = useFragment_experimental;
 exports.useLazyQuery = useLazyQuery;
 exports.useMutation = useMutation;
 exports.useQuery = useQuery;