@apollo/client 3.13.3 → 4.0.0-alpha.0

package/utilities/graphql/transform.js

@@ -1,11 +1,11 @@
-import { __assign, __spreadArray } from "tslib";
-import { invariant } from "../globals/index.js";
-import { visit, Kind } from "graphql";
-import { checkDocument, getOperationDefinition, getFragmentDefinition, getFragmentDefinitions, getMainDefinition, } from "./getFromAST.js";
-import { isField } from "./storeUtils.js";
-import { createFragmentMap } from "./fragments.js";
+import { __DEV__ } from "@apollo/client/utilities/environment";
+import { Kind, visit } from "graphql";
+import { invariant } from "@apollo/client/utilities/invariant";
 import { isArray, isNonEmptyArray } from "../common/arrays.js";
-var TYPENAME_FIELD = {
+import { createFragmentMap } from "./fragments.js";
+import { checkDocument, getFragmentDefinition, getFragmentDefinitions, getMainDefinition, getOperationDefinition, } from "./getFromAST.js";
+import { isField } from "./storeUtils.js";
+const TYPENAME_FIELD = {
     kind: Kind.FIELD,
     name: {
         kind: Kind.NAME,
@@ -14,10 +14,8 @@ var TYPENAME_FIELD = {
 };
 function isEmpty(op, fragmentMap) {
     return (!op ||
-        op.selectionSet.selections.every(function (selection) {
-            return selection.kind === Kind.FRAGMENT_SPREAD &&
-                isEmpty(fragmentMap[selection.name.value], fragmentMap);
-        }));
+        op.selectionSet.selections.every((selection) => selection.kind === Kind.FRAGMENT_SPREAD &&
+            isEmpty(fragmentMap[selection.name.value], fragmentMap)));
 }
 function nullIfDocIsEmpty(doc) {
     return (isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))) ?
@@ -25,9 +23,9 @@ function nullIfDocIsEmpty(doc) {
         : doc;
 }
 function getDirectiveMatcher(configs) {
-    var names = new Map();
-    var tests = new Map();
-    configs.forEach(function (directive) {
+    const names = new Map();
+    const tests = new Map();
+    configs.forEach((directive) => {
         if (directive) {
             if (directive.name) {
                 names.set(directive.name, directive);
@@ -37,10 +35,10 @@ function getDirectiveMatcher(configs) {
             }
         }
     });
-    return function (directive) {
-        var config = names.get(directive.name.value);
+    return (directive) => {
+        let config = names.get(directive.name.value);
         if (!config && tests.size) {
-            tests.forEach(function (testConfig, test) {
+            tests.forEach((testConfig, test) => {
                 if (test(directive)) {
                     config = testConfig;
                 }
@@ -50,10 +48,9 @@ function getDirectiveMatcher(configs) {
     };
 }
 function makeInUseGetterFunction(defaultKey) {
-    var map = new Map();
-    return function inUseGetterFunction(key) {
-        if (key === void 0) { key = defaultKey; }
-        var inUse = map.get(key);
+    const map = new Map();
+    return function inUseGetterFunction(key = defaultKey) {
+        let inUse = map.get(key);
         if (!inUse) {
             map.set(key, (inUse = {
                 // Variable and fragment spread names used directly within this
@@ -73,10 +70,10 @@ export function removeDirectivesFromDocument(directives, doc) {
     // operations as if their names were "". Anonymous fragment definitions are
     // not supposed to be possible, but the same default naming strategy seems
     // appropriate for that case as well.
-    var getInUseByOperationName = makeInUseGetterFunction("");
-    var getInUseByFragmentName = makeInUseGetterFunction("");
-    var getInUse = function (ancestors) {
-        for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {
+    const getInUseByOperationName = makeInUseGetterFunction("");
+    const getInUseByFragmentName = makeInUseGetterFunction("");
+    const getInUse = (ancestors) => {
+        for (let p = 0, ancestor; p < ancestors.length && (ancestor = ancestors[p]); ++p) {
             if (isArray(ancestor))
                 continue;
             if (ancestor.kind === Kind.OPERATION_DEFINITION) {
@@ -87,43 +84,41 @@ export function removeDirectivesFromDocument(directives, doc) {
                 return getInUseByFragmentName(ancestor.name.value);
             }
         }
-        globalThis.__DEV__ !== false && invariant.error(97);
+        __DEV__ && invariant.error(21);
         return null;
     };
-    var operationCount = 0;
-    for (var i = doc.definitions.length - 1; i >= 0; --i) {
+    let operationCount = 0;
+    for (let i = doc.definitions.length - 1; i >= 0; --i) {
         if (doc.definitions[i].kind === Kind.OPERATION_DEFINITION) {
             ++operationCount;
         }
     }
-    var directiveMatcher = getDirectiveMatcher(directives);
-    var shouldRemoveField = function (nodeDirectives) {
-        return isNonEmptyArray(nodeDirectives) &&
-            nodeDirectives
-                .map(directiveMatcher)
-                .some(function (config) { return config && config.remove; });
-    };
-    var originalFragmentDefsByPath = new Map();
+    const directiveMatcher = getDirectiveMatcher(directives);
+    const shouldRemoveField = (nodeDirectives) => isNonEmptyArray(nodeDirectives) &&
+        nodeDirectives
+            .map(directiveMatcher)
+            .some((config) => config && config.remove);
+    const originalFragmentDefsByPath = new Map();
     // Any time the first traversal of the document below makes a change like
     // removing a fragment (by returning null), this variable should be set to
     // true. Once it becomes true, it should never be set to false again. If this
     // variable remains false throughout the traversal, then we can return the
     // original doc immediately without any modifications.
-    var firstVisitMadeChanges = false;
-    var fieldOrInlineFragmentVisitor = {
-        enter: function (node) {
+    let firstVisitMadeChanges = false;
+    const fieldOrInlineFragmentVisitor = {
+        enter(node) {
             if (shouldRemoveField(node.directives)) {
                 firstVisitMadeChanges = true;
                 return null;
             }
         },
     };
-    var docWithoutDirectiveSubtrees = visit(doc, {
+    const docWithoutDirectiveSubtrees = visit(doc, {
         // These two AST node types share the same implementation, defined above.
         Field: fieldOrInlineFragmentVisitor,
         InlineFragment: fieldOrInlineFragmentVisitor,
         VariableDefinition: {
-            enter: function () {
+            enter() {
                 // VariableDefinition nodes do not count as variables in use, though
                 // they do contain Variable nodes that might be visited below. To avoid
                 // counting variable declarations as usages, we skip visiting the
@@ -132,20 +127,20 @@ export function removeDirectivesFromDocument(directives, doc) {
             },
         },
         Variable: {
-            enter: function (node, _key, _parent, _path, ancestors) {
-                var inUse = getInUse(ancestors);
+            enter(node, _key, _parent, _path, ancestors) {
+                const inUse = getInUse(ancestors);
                 if (inUse) {
                     inUse.variables.add(node.name.value);
                 }
             },
         },
         FragmentSpread: {
-            enter: function (node, _key, _parent, _path, ancestors) {
+            enter(node, _key, _parent, _path, ancestors) {
                 if (shouldRemoveField(node.directives)) {
                     firstVisitMadeChanges = true;
                     return null;
                 }
-                var inUse = getInUse(ancestors);
+                const inUse = getInUse(ancestors);
                 if (inUse) {
                     inUse.fragmentSpreads.add(node.name.value);
                 }
@@ -157,11 +152,11 @@ export function removeDirectivesFromDocument(directives, doc) {
             },
         },
         FragmentDefinition: {
-            enter: function (node, _key, _parent, path) {
+            enter(node, _key, _parent, path) {
                 originalFragmentDefsByPath.set(JSON.stringify(path), node);
             },
-            leave: function (node, _key, _parent, path) {
-                var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));
+            leave(node, _key, _parent, path) {
+                const originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));
                 if (node === originalNode) {
                     // If the FragmentNode received by this leave function is identical to
                     // the one received by the corresponding enter function (above), then
@@ -176,10 +171,8 @@ export function removeDirectivesFromDocument(directives, doc) {
                 // operations, since removing all fragments from a document containing
                 // only fragments makes the document useless.
                 operationCount > 0 &&
-                    node.selectionSet.selections.every(function (selection) {
-                        return selection.kind === Kind.FIELD &&
-                            selection.name.value === "__typename";
-                    })) {
+                    node.selectionSet.selections.every((selection) => selection.kind === Kind.FIELD &&
+                        selection.name.value === "__typename")) {
                     // This is a somewhat opinionated choice: if a FragmentDefinition ends
                     // up having no fields other than __typename, we remove the whole
                     // fragment definition, and later prune ...spread references to it.
@@ -190,7 +183,7 @@ export function removeDirectivesFromDocument(directives, doc) {
             },
         },
         Directive: {
-            leave: function (node) {
+            leave(node) {
                 // If a matching directive is found, remove the directive itself. Note
                 // that this does not remove the target (field, argument, etc) of the
                 // directive, but only the directive itself.
@@ -211,12 +204,12 @@ export function removeDirectivesFromDocument(directives, doc) {
     // populated and inUse.removed has been set if appropriate,
     // populateTransitiveVars must be called after that information has been
     // collected by the first traversal of the document.
-    var populateTransitiveVars = function (inUse) {
+    const populateTransitiveVars = (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.fragmentSpreads.forEach((childFragmentName) => {
+                    populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach((varName) => {
                         inUse.transitiveVars.add(varName);
                     });
                 });
@@ -227,10 +220,10 @@ export function removeDirectivesFromDocument(directives, doc) {
     // Since we've been keeping track of fragment spreads used by particular
     // operations and fragment definitions, we now need to compute the set of all
     // spreads used (transitively) by any operations in the document.
-    var allFragmentNamesUsed = new Set();
-    docWithoutDirectiveSubtrees.definitions.forEach(function (def) {
+    const allFragmentNamesUsed = new Set();
+    docWithoutDirectiveSubtrees.definitions.forEach((def) => {
         if (def.kind === Kind.OPERATION_DEFINITION) {
-            populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function (childFragmentName) {
+            populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach((childFragmentName) => {
                 allFragmentNamesUsed.add(childFragmentName);
             });
         }
@@ -247,23 +240,21 @@ export function removeDirectivesFromDocument(directives, doc) {
     // Now that we have added all fragment spreads used by operations to the
     // allFragmentNamesUsed set, we can complete the set by transitively adding
     // all fragment spreads used by those fragments, and so on.
-    allFragmentNamesUsed.forEach(function (fragmentName) {
+    allFragmentNamesUsed.forEach((fragmentName) => {
         // Once all the childFragmentName strings added here have been seen already,
         // the top-level allFragmentNamesUsed.forEach loop will terminate.
-        populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function (childFragmentName) {
+        populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach((childFragmentName) => {
             allFragmentNamesUsed.add(childFragmentName);
         });
     });
-    var fragmentWillBeRemoved = function (fragmentName) {
-        return !!(
-        // A fragment definition will be removed if there are no spreads that refer
-        // to it, or the fragment was explicitly removed because it had no fields
-        // other than __typename.
-        (!allFragmentNamesUsed.has(fragmentName) ||
-            getInUseByFragmentName(fragmentName).removed));
-    };
-    var enterVisitor = {
-        enter: function (node) {
+    const fragmentWillBeRemoved = (fragmentName) => !!(
+    // A fragment definition will be removed if there are no spreads that refer
+    // to it, or the fragment was explicitly removed because it had no fields
+    // other than __typename.
+    (!allFragmentNamesUsed.has(fragmentName) ||
+        getInUseByFragmentName(fragmentName).removed));
+    const enterVisitor = {
+        enter(node) {
             if (fragmentWillBeRemoved(node.name.value)) {
                 return null;
             }
@@ -276,11 +267,11 @@ export function removeDirectivesFromDocument(directives, doc) {
         // This is where the fragment definition is actually removed.
         FragmentDefinition: enterVisitor,
         OperationDefinition: {
-            leave: function (node) {
+            leave(node) {
                 // Upon leaving each operation in the depth-first AST traversal, prune
                 // any variables that are declared by the operation but unused within.
                 if (node.variableDefinitions) {
-                    var usedVariableNames_1 = populateTransitiveVars(
+                    const usedVariableNames = populateTransitiveVars(
                     // If an operation is anonymous, we use the empty string as its key.
                     getInUseByOperationName(node.name && node.name.value)).transitiveVars;
                     // According to the GraphQL spec, all variables declared by an
@@ -294,20 +285,21 @@ export function removeDirectivesFromDocument(directives, doc) {
                     // enclosing operation. This pruning applies only to operations and
                     // not fragment definitions, at the moment. Fragments may be able to
                     // declare variables eventually, but today they can only consume them.
-                    if (usedVariableNames_1.size < node.variableDefinitions.length) {
-                        return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {
-                                return usedVariableNames_1.has(varDef.variable.name.value);
-                            }) });
+                    if (usedVariableNames.size < node.variableDefinitions.length) {
+                        return {
+                            ...node,
+                            variableDefinitions: node.variableDefinitions.filter((varDef) => usedVariableNames.has(varDef.variable.name.value)),
+                        };
                     }
                 }
             },
         },
     }));
 }
-export var addTypenameToDocument = Object.assign(function (doc) {
+export const addTypenameToDocument = Object.assign(function (doc) {
     return visit(doc, {
         SelectionSet: {
-            enter: function (node, _key, parent) {
+            enter(node, _key, parent) {
                 // Don't add __typename to OperationDefinitions.
                 if (parent &&
                     parent.kind ===
@@ -315,13 +307,13 @@ export var addTypenameToDocument = Object.assign(function (doc) {
                     return;
                 }
                 // No changes if no selections.
-                var selections = node.selections;
+                const { selections } = node;
                 if (!selections) {
                     return;
                 }
                 // If selections already have a __typename, or are part of an
                 // introspection query, do nothing.
-                var skip = selections.some(function (selection) {
+                const skip = selections.some((selection) => {
                     return (isField(selection) &&
                         (selection.name.value === "__typename" ||
                             selection.name.value.lastIndexOf("__", 0) === 0));
@@ -331,29 +323,32 @@ export var addTypenameToDocument = Object.assign(function (doc) {
                 }
                 // If this SelectionSet is @export-ed as an input variable, it should
                 // not have a __typename field (see issue #4691).
-                var field = parent;
+                const field = parent;
                 if (isField(field) &&
                     field.directives &&
-                    field.directives.some(function (d) { return d.name.value === "export"; })) {
+                    field.directives.some((d) => d.name.value === "export")) {
                     return;
                 }
                 // Create and return a new SelectionSet with a __typename Field.
-                return __assign(__assign({}, node), { selections: __spreadArray(__spreadArray([], selections, true), [TYPENAME_FIELD], false) });
+                return {
+                    ...node,
+                    selections: [...selections, TYPENAME_FIELD],
+                };
             },
         },
     });
 }, {
-    added: function (field) {
+    added(field) {
         return field === TYPENAME_FIELD;
     },
 });
-var connectionRemoveConfig = {
-    test: function (directive) {
-        var willRemove = directive.name.value === "connection";
+const connectionRemoveConfig = {
+    test: (directive) => {
+        const willRemove = directive.name.value === "connection";
         if (willRemove) {
             if (!directive.arguments ||
-                !directive.arguments.some(function (arg) { return arg.name.value === "key"; })) {
-                globalThis.__DEV__ !== false && invariant.warn(98);
+                !directive.arguments.some((arg) => arg.name.value === "key")) {
+                __DEV__ && invariant.warn(22);
             }
         }
         return willRemove;
@@ -362,16 +357,12 @@ var connectionRemoveConfig = {
 export function removeConnectionDirectiveFromDocument(doc) {
     return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));
 }
-function hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {
-    if (nestedCheck === void 0) { nestedCheck = true; }
+function hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck = true) {
     return (!!selectionSet &&
         selectionSet.selections &&
-        selectionSet.selections.some(function (selection) {
-            return hasDirectivesInSelection(directives, selection, nestedCheck);
-        }));
+        selectionSet.selections.some((selection) => hasDirectivesInSelection(directives, selection, nestedCheck)));
 }
-function hasDirectivesInSelection(directives, selection, nestedCheck) {
-    if (nestedCheck === void 0) { nestedCheck = true; }
+function hasDirectivesInSelection(directives, selection, nestedCheck = true) {
     if (!isField(selection)) {
         return true;
     }
@@ -384,51 +375,49 @@ function hasDirectivesInSelection(directives, selection, nestedCheck) {
 }
 function getArgumentMatcher(config) {
     return function argumentMatcher(argument) {
-        return config.some(function (aConfig) {
-            return argument.value &&
-                argument.value.kind === Kind.VARIABLE &&
-                argument.value.name &&
-                (aConfig.name === argument.value.name.value ||
-                    (aConfig.test && aConfig.test(argument)));
-        });
+        return config.some((aConfig) => argument.value &&
+            argument.value.kind === Kind.VARIABLE &&
+            argument.value.name &&
+            (aConfig.name === argument.value.name.value ||
+                (aConfig.test && aConfig.test(argument))));
     };
 }
 export function removeArgumentsFromDocument(config, doc) {
-    var argMatcher = getArgumentMatcher(config);
+    const argMatcher = getArgumentMatcher(config);
     return nullIfDocIsEmpty(visit(doc, {
         OperationDefinition: {
-            enter: function (node) {
-                return __assign(__assign({}, node), { 
+            enter(node) {
+                return {
+                    ...node,
                     // Remove matching top level variables definitions.
                     variableDefinitions: node.variableDefinitions ?
-                        node.variableDefinitions.filter(function (varDef) {
-                            return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });
-                        })
-                        : [] });
+                        node.variableDefinitions.filter((varDef) => !config.some((arg) => arg.name === varDef.variable.name.value))
+                        : [],
+                };
             },
         },
         Field: {
-            enter: function (node) {
+            enter(node) {
                 // If `remove` is set to true for an argument, and an argument match
                 // is found for a field, remove the field as well.
-                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });
+                const shouldRemoveField = config.some((argConfig) => argConfig.remove);
                 if (shouldRemoveField) {
-                    var argMatchCount_1 = 0;
+                    let argMatchCount = 0;
                     if (node.arguments) {
-                        node.arguments.forEach(function (arg) {
+                        node.arguments.forEach((arg) => {
                             if (argMatcher(arg)) {
-                                argMatchCount_1 += 1;
+                                argMatchCount += 1;
                             }
                         });
                     }
-                    if (argMatchCount_1 === 1) {
+                    if (argMatchCount === 1) {
                         return null;
                     }
                 }
             },
         },
         Argument: {
-            enter: function (node) {
+            enter(node) {
                 // Remove all matching arguments.
                 if (argMatcher(node)) {
                     return null;
@@ -439,30 +428,33 @@ export function removeArgumentsFromDocument(config, doc) {
 }
 export function removeFragmentSpreadFromDocument(config, doc) {
     function enter(node) {
-        if (config.some(function (def) { return def.name === node.name.value; })) {
+        if (config.some((def) => def.name === node.name.value)) {
             return null;
         }
     }
     return nullIfDocIsEmpty(visit(doc, {
-        FragmentSpread: { enter: enter },
-        FragmentDefinition: { enter: enter },
+        FragmentSpread: { enter },
+        FragmentDefinition: { enter },
     }));
 }
 // If the incoming document is a query, return it as is. Otherwise, build a
 // new document containing a query operation based on the selection set
 // of the previous main operation.
 export function buildQueryFromSelectionSet(document) {
-    var definition = getMainDefinition(document);
-    var definitionOperation = definition.operation;
+    const definition = getMainDefinition(document);
+    const definitionOperation = definition.operation;
     if (definitionOperation === "query") {
         // Already a query, so return the existing document.
         return document;
     }
     // Build a new query using the selection set of the main operation.
-    var modifiedDoc = visit(document, {
+    const modifiedDoc = visit(document, {
         OperationDefinition: {
-            enter: function (node) {
-                return __assign(__assign({}, node), { operation: "query" });
+            enter(node) {
+                return {
+                    ...node,
+                    operation: "query",
+                };
             },
         },
     });
@@ -471,9 +463,9 @@ export function buildQueryFromSelectionSet(document) {
 // Remove fields / selection sets that include an @client directive.
 export function removeClientSetsFromDocument(document) {
     checkDocument(document);
-    var modifiedDoc = removeDirectivesFromDocument([
+    let modifiedDoc = removeDirectivesFromDocument([
         {
-            test: function (directive) { return directive.name.value === "client"; },
+            test: (directive) => directive.name.value === "client",
             remove: true,
         },
     ], document);
@@ -482,20 +474,23 @@ export function removeClientSetsFromDocument(document) {
 export function addNonReactiveToNamedFragments(document) {
     checkDocument(document);
     return visit(document, {
-        FragmentSpread: function (node) {
-            var _a;
+        FragmentSpread: (node) => {
             // Do not add `@nonreactive` if the fragment is marked with `@unmask`
             // since we want to react to changes in this fragment.
-            if ((_a = node.directives) === null || _a === void 0 ? void 0 : _a.some(function (directive) { return directive.name.value === "unmask"; })) {
+            if (node.directives?.some((directive) => directive.name.value === "unmask")) {
                 return;
             }
-            return __assign(__assign({}, node), { directives: __spreadArray(__spreadArray([], (node.directives || []), true), [
+            return {
+                ...node,
+                directives: [
+                    ...(node.directives || []),
                     {
                         kind: Kind.DIRECTIVE,
                         name: { kind: Kind.NAME, value: "nonreactive" },
                     },
-                ], false) });
+                ],
+            };
         },
     });
 }
-//# sourceMappingURL=transform.js.map
+//# sourceMappingURL=transform.js.map