@apollo/client 3.7.8 → 3.7.10

package/README.md

@@ -37,7 +37,7 @@ Learn how to use Apollo Client with self-paced hands-on training on Odyssey, Apo
 
 - [Apollo Studio](https://www.apollographql.com/studio/develop/) – A free, end-to-end platform for managing your GraphQL lifecycle. Track your GraphQL schemas in a hosted registry to create a source of truth for everything in your graph. Studio provides an IDE (Apollo Explorer) so you can explore data, collaborate on queries, observe usage, and safely make schema changes.
 - [Apollo Federation](https://www.apollographql.com/apollo-federation) – The industry-standard open architecture for building a distributed graph. Use Apollo’s gateway to compose a unified graph from multiple subgraphs, determine a query plan, and route requests across your services.
-- [Apollo Client](https://www.apollographql.com/apollo-client/) – The most popular GraphQL client for the web. Apollo also builds and maintains [Apollo iOS](https://github.com/apollographql/apollo-ios) and [Apollo Android](https://github.com/apollographql/apollo-android).
+- [Apollo Client](https://www.apollographql.com/apollo-client/) – The most popular GraphQL client for the web. Apollo also builds and maintains [Apollo iOS](https://github.com/apollographql/apollo-ios) and [Apollo Kotlin](https://github.com/apollographql/apollo-kotlin).
 - [Apollo Server](https://www.apollographql.com/docs/apollo-server/) – A production-ready JavaScript GraphQL server that connects to any microservice, API, or database. Compatible with all popular JavaScript frameworks and deployable in serverless environments.
 
 ## Learn how to build with Apollo

package/apollo-client.cjs

@@ -380,17 +380,21 @@ function checkDocument(doc) {
 }
 function getOperationDefinition(doc) {
     checkDocument(doc);
-    return doc.definitions.filter(function (definition) { return definition.kind === 'OperationDefinition'; })[0];
+    return doc.definitions.filter(function (definition) {
+        return definition.kind === 'OperationDefinition';
+    })[0];
 }
 function getOperationName(doc) {
     return (doc.definitions
         .filter(function (definition) {
-        return definition.kind === 'OperationDefinition' && definition.name;
+        return definition.kind === 'OperationDefinition' && !!definition.name;
     })
         .map(function (x) { return x.name.value; })[0] || null);
 }
 function getFragmentDefinitions(doc) {
-    return doc.definitions.filter(function (definition) { return definition.kind === 'FragmentDefinition'; });
+    return doc.definitions.filter(function (definition) {
+        return definition.kind === 'FragmentDefinition';
+    });
 }
 function getQueryDefinition(doc) {
     var queryDef = getOperationDefinition(doc);
@@ -439,26 +443,20 @@ function getDefaultValues(definition) {
     return defaultValues;
 }
 
-function filterInPlace(array, test, context) {
-    var target = 0;
-    array.forEach(function (elem, i) {
-        if (test.call(this, elem, i, array)) {
-            array[target++] = elem;
-        }
-    }, context);
-    array.length = target;
-    return array;
+var isArray = Array.isArray;
+function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
 }
 
 var TYPENAME_FIELD = {
-    kind: 'Field',
+    kind: graphql.Kind.FIELD,
     name: {
-        kind: 'Name',
+        kind: graphql.Kind.NAME,
         value: '__typename',
     },
 };
 function isEmpty(op, fragmentMap) {
-    return !op || op.selectionSet.selections.every(function (selection) { return selection.kind === 'FragmentSpread' &&
+    return !op || op.selectionSet.selections.every(function (selection) { return selection.kind === graphql.Kind.FRAGMENT_SPREAD &&
         isEmpty(fragmentMap[selection.name.value], fragmentMap); });
 }
 function nullIfDocIsEmpty(doc) {
@@ -467,84 +465,190 @@ function nullIfDocIsEmpty(doc) {
         : doc;
 }
 function getDirectiveMatcher(directives) {
-    return function directiveMatcher(directive) {
-        return directives.some(function (dir) {
-            return (dir.name && dir.name === directive.name.value) ||
-                (dir.test && dir.test(directive));
-        });
+    var nameSet = new Set();
+    var tests = [];
+    directives.forEach(function (directive) {
+        if (directive.name) {
+            nameSet.add(directive.name);
+        }
+        else if (directive.test) {
+            tests.push(directive.test);
+        }
+    });
+    return function (directive) { return (nameSet.has(directive.name.value) ||
+        tests.some(function (test) { return test(directive); })); };
+}
+function makeInUseGetterFunction(defaultKey) {
+    var map = new Map();
+    return function inUseGetterFunction(key) {
+        if (key === void 0) { key = defaultKey; }
+        var inUse = map.get(key);
+        if (!inUse) {
+            map.set(key, inUse = {
+                variables: new Set,
+                fragmentSpreads: new Set,
+            });
+        }
+        return inUse;
     };
 }
 function removeDirectivesFromDocument(directives, doc) {
-    var variablesInUse = Object.create(null);
-    var variablesToRemove = [];
-    var fragmentSpreadsInUse = Object.create(null);
-    var fragmentSpreadsToRemove = [];
-    var modifiedDoc = nullIfDocIsEmpty(graphql.visit(doc, {
+    var getInUseByOperationName = makeInUseGetterFunction("");
+    var getInUseByFragmentName = makeInUseGetterFunction("");
+    var getInUse = function (ancestors) {
+        for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {
+            if (isArray(ancestor))
+                continue;
+            if (ancestor.kind === graphql.Kind.OPERATION_DEFINITION) {
+                return getInUseByOperationName(ancestor.name && ancestor.name.value);
+            }
+            if (ancestor.kind === graphql.Kind.FRAGMENT_DEFINITION) {
+                return getInUseByFragmentName(ancestor.name.value);
+            }
+        }
+        __DEV__ && tsInvariant.invariant.error("Could not find operation or fragment");
+        return null;
+    };
+    var operationCount = 0;
+    for (var i = doc.definitions.length - 1; i >= 0; --i) {
+        if (doc.definitions[i].kind === graphql.Kind.OPERATION_DEFINITION) {
+            ++operationCount;
+        }
+    }
+    var directiveMatcher = getDirectiveMatcher(directives);
+    var hasRemoveDirective = directives.some(function (directive) { return directive.remove; });
+    var shouldRemoveField = function (nodeDirectives) { return (hasRemoveDirective &&
+        nodeDirectives &&
+        nodeDirectives.some(directiveMatcher)); };
+    var originalFragmentDefsByPath = new Map();
+    var firstVisitMadeChanges = false;
+    var fieldOrInlineFragmentVisitor = {
+        enter: function (node) {
+            if (shouldRemoveField(node.directives)) {
+                firstVisitMadeChanges = true;
+                return null;
+            }
+        },
+    };
+    var docWithoutDirectiveSubtrees = graphql.visit(doc, {
+        Field: fieldOrInlineFragmentVisitor,
+        InlineFragment: fieldOrInlineFragmentVisitor,
+        VariableDefinition: {
+            enter: function () {
+                return false;
+            },
+        },
         Variable: {
-            enter: function (node, _key, parent) {
-                if (parent.kind !== 'VariableDefinition') {
-                    variablesInUse[node.name.value] = true;
+            enter: function (node, _key, _parent, _path, ancestors) {
+                var inUse = getInUse(ancestors);
+                if (inUse) {
+                    inUse.variables.add(node.name.value);
                 }
             },
         },
-        Field: {
-            enter: function (node) {
-                if (directives && node.directives) {
-                    var shouldRemoveField = directives.some(function (directive) { return directive.remove; });
-                    if (shouldRemoveField &&
-                        node.directives &&
-                        node.directives.some(getDirectiveMatcher(directives))) {
-                        if (node.arguments) {
-                            node.arguments.forEach(function (arg) {
-                                if (arg.value.kind === 'Variable') {
-                                    variablesToRemove.push({
-                                        name: arg.value.name.value,
-                                    });
-                                }
-                            });
-                        }
-                        if (node.selectionSet) {
-                            getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(function (frag) {
-                                fragmentSpreadsToRemove.push({
-                                    name: frag.name.value,
-                                });
-                            });
-                        }
-                        return null;
-                    }
+        FragmentSpread: {
+            enter: function (node, _key, _parent, _path, ancestors) {
+                if (shouldRemoveField(node.directives)) {
+                    firstVisitMadeChanges = true;
+                    return null;
+                }
+                var inUse = getInUse(ancestors);
+                if (inUse) {
+                    inUse.fragmentSpreads.add(node.name.value);
                 }
             },
         },
-        FragmentSpread: {
-            enter: function (node) {
-                fragmentSpreadsInUse[node.name.value] = true;
+        FragmentDefinition: {
+            enter: function (node, _key, _parent, path) {
+                originalFragmentDefsByPath.set(JSON.stringify(path), node);
+            },
+            leave: function (node, _key, _parent, path) {
+                var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));
+                if (node === originalNode) {
+                    return node;
+                }
+                if (operationCount > 0 &&
+                    node.selectionSet.selections.every(function (selection) { return (selection.kind === graphql.Kind.FIELD &&
+                        selection.name.value === '__typename'); })) {
+                    getInUseByFragmentName(node.name.value).removed = true;
+                    firstVisitMadeChanges = true;
+                    return null;
+                }
             },
         },
         Directive: {
-            enter: function (node) {
-                if (getDirectiveMatcher(directives)(node)) {
+            leave: function (node) {
+                if (directiveMatcher(node)) {
+                    firstVisitMadeChanges = true;
                     return null;
                 }
             },
         },
+    });
+    if (!firstVisitMadeChanges) {
+        return doc;
+    }
+    var populateTransitiveVars = function (inUse) {
+        if (!inUse.transitiveVars) {
+            inUse.transitiveVars = new Set(inUse.variables);
+            if (!inUse.removed) {
+                inUse.fragmentSpreads.forEach(function (childFragmentName) {
+                    populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach(function (varName) {
+                        inUse.transitiveVars.add(varName);
+                    });
+                });
+            }
+        }
+        return inUse;
+    };
+    var allFragmentNamesUsed = new Set();
+    docWithoutDirectiveSubtrees.definitions.forEach(function (def) {
+        if (def.kind === graphql.Kind.OPERATION_DEFINITION) {
+            populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function (childFragmentName) {
+                allFragmentNamesUsed.add(childFragmentName);
+            });
+        }
+        else if (def.kind === graphql.Kind.FRAGMENT_DEFINITION &&
+            operationCount === 0 &&
+            !getInUseByFragmentName(def.name.value).removed) {
+            allFragmentNamesUsed.add(def.name.value);
+        }
+    });
+    allFragmentNamesUsed.forEach(function (fragmentName) {
+        populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function (childFragmentName) {
+            allFragmentNamesUsed.add(childFragmentName);
+        });
+    });
+    var fragmentWillBeRemoved = function (fragmentName) { return !!(!allFragmentNamesUsed.has(fragmentName) ||
+        getInUseByFragmentName(fragmentName).removed); };
+    var enterVisitor = {
+        enter: function (node) {
+            if (fragmentWillBeRemoved(node.name.value)) {
+                return null;
+            }
+        },
+    };
+    return nullIfDocIsEmpty(graphql.visit(docWithoutDirectiveSubtrees, {
+        FragmentSpread: enterVisitor,
+        FragmentDefinition: enterVisitor,
+        OperationDefinition: {
+            leave: function (node) {
+                if (node.variableDefinitions) {
+                    var usedVariableNames_1 = populateTransitiveVars(getInUseByOperationName(node.name && node.name.value)).transitiveVars;
+                    if (usedVariableNames_1.size < node.variableDefinitions.length) {
+                        return tslib.__assign(tslib.__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) { return usedVariableNames_1.has(varDef.variable.name.value); }) });
+                    }
+                }
+            },
+        },
     }));
-    if (modifiedDoc &&
-        filterInPlace(variablesToRemove, function (v) { return !!v.name && !variablesInUse[v.name]; }).length) {
-        modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);
-    }
-    if (modifiedDoc &&
-        filterInPlace(fragmentSpreadsToRemove, function (fs) { return !!fs.name && !fragmentSpreadsInUse[fs.name]; })
-            .length) {
-        modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);
-    }
-    return modifiedDoc;
 }
 var addTypenameToDocument = Object.assign(function (doc) {
     return graphql.visit(doc, {
         SelectionSet: {
             enter: function (node, _key, parent) {
                 if (parent &&
-                    parent.kind === 'OperationDefinition') {
+                    parent.kind === graphql.Kind.OPERATION_DEFINITION) {
                     return;
                 }
                 var selections = node.selections;
@@ -590,78 +694,6 @@ var connectionRemoveConfig = {
 function removeConnectionDirectiveFromDocument(doc) {
     return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));
 }
-function getArgumentMatcher(config) {
-    return function argumentMatcher(argument) {
-        return config.some(function (aConfig) {
-            return argument.value &&
-                argument.value.kind === 'Variable' &&
-                argument.value.name &&
-                (aConfig.name === argument.value.name.value ||
-                    (aConfig.test && aConfig.test(argument)));
-        });
-    };
-}
-function removeArgumentsFromDocument(config, doc) {
-    var argMatcher = getArgumentMatcher(config);
-    return nullIfDocIsEmpty(graphql.visit(doc, {
-        OperationDefinition: {
-            enter: function (node) {
-                return tslib.__assign(tslib.__assign({}, node), { variableDefinitions: node.variableDefinitions ? node.variableDefinitions.filter(function (varDef) {
-                        return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });
-                    }) : [] });
-            },
-        },
-        Field: {
-            enter: function (node) {
-                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });
-                if (shouldRemoveField) {
-                    var argMatchCount_1 = 0;
-                    if (node.arguments) {
-                        node.arguments.forEach(function (arg) {
-                            if (argMatcher(arg)) {
-                                argMatchCount_1 += 1;
-                            }
-                        });
-                    }
-                    if (argMatchCount_1 === 1) {
-                        return null;
-                    }
-                }
-            },
-        },
-        Argument: {
-            enter: function (node) {
-                if (argMatcher(node)) {
-                    return null;
-                }
-            },
-        },
-    }));
-}
-function removeFragmentSpreadFromDocument(config, doc) {
-    function enter(node) {
-        if (config.some(function (def) { return def.name === node.name.value; })) {
-            return null;
-        }
-    }
-    return nullIfDocIsEmpty(graphql.visit(doc, {
-        FragmentSpread: { enter: enter },
-        FragmentDefinition: { enter: enter },
-    }));
-}
-function getAllFragmentSpreadsFromSelectionSet(selectionSet) {
-    var allFragments = [];
-    selectionSet.selections.forEach(function (selection) {
-        if ((isField(selection) || isInlineFragment(selection)) &&
-            selection.selectionSet) {
-            getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(function (frag) { return allFragments.push(frag); });
-        }
-        else if (selection.kind === 'FragmentSpread') {
-            allFragments.push(selection);
-        }
-    });
-    return allFragments;
-}
 function buildQueryFromSelectionSet(document) {
     var definition = getMainDefinition(document);
     var definitionOperation = definition.operation;
@@ -685,22 +717,6 @@ function removeClientSetsFromDocument(document) {
             remove: true,
         },
     ], document);
-    if (modifiedDoc) {
-        modifiedDoc = graphql.visit(modifiedDoc, {
-            FragmentDefinition: {
-                enter: function (node) {
-                    if (node.selectionSet) {
-                        var isTypenameOnly = node.selectionSet.selections.every(function (selection) {
-                            return isField(selection) && selection.name.value === '__typename';
-                        });
-                        if (isTypenameOnly) {
-                            return null;
-                        }
-                    }
-                },
-            },
-        });
-    }
     return modifiedDoc;
 }
 
@@ -1049,10 +1065,6 @@ var Concast = (function (_super) {
 }(zenObservableTs.Observable));
 fixObservableSubclass(Concast);
 
-function isNonEmptyArray(value) {
-    return Array.isArray(value) && value.length > 0;
-}
-
 function isExecutionPatchIncrementalResult(value) {
     return "incremental" in value;
 }
@@ -1345,7 +1357,7 @@ var concat = ApolloLink.concat;
 
 var execute = ApolloLink.execute;
 
-var version = '3.7.8';
+var version = '3.7.10';
 
 function isNodeResponse(value) {
     return !!value.body;
@@ -2041,7 +2053,6 @@ var hasOwn = Object.prototype.hasOwnProperty;
 function isNullish(value) {
     return value === null || value === void 0;
 }
-var isArray = Array.isArray;
 function defaultDataIdFromObject(_a, context) {
     var __typename = _a.__typename, id = _a.id, _id = _a._id;
     if (typeof __typename === "string") {
@@ -6367,12 +6378,18 @@ var ApolloClient = (function () {
         return this.cache.readFragment(options, optimistic);
     };
     ApolloClient.prototype.writeQuery = function (options) {
-        this.cache.writeQuery(options);
-        this.queryManager.broadcastQueries();
+        var ref = this.cache.writeQuery(options);
+        if (options.broadcast !== false) {
+            this.queryManager.broadcastQueries();
+        }
+        return ref;
     };
     ApolloClient.prototype.writeFragment = function (options) {
-        this.cache.writeFragment(options);
-        this.queryManager.broadcastQueries();
+        var ref = this.cache.writeFragment(options);
+        if (options.broadcast !== false) {
+            this.queryManager.broadcastQueries();
+        }
+        return ref;
     };
     ApolloClient.prototype.__actionHookForDevTools = function (cb) {
         this.devToolsHookCb = cb;
@@ -7020,8 +7037,9 @@ function useMutation(mutation, options) {
     }
     var execute = React.useCallback(function (executeOptions) {
         if (executeOptions === void 0) { executeOptions = {}; }
-        var _a = ref.current, client = _a.client, options = _a.options, mutation = _a.mutation;
+        var _a = ref.current, options = _a.options, mutation = _a.mutation;
         var baseOptions = tslib.__assign(tslib.__assign({}, options), { mutation: mutation });
+        var client = executeOptions.client || ref.current.client;
         if (!ref.current.result.loading && !baseOptions.ignoreResults && ref.current.isMounted) {
             setResult(ref.current.result = {
                 loading: true,