@slicemachine/manager 0.1.1-dev-plugins.3

package/dist/__node_modules/graphql/validation/rules/NoUnusedVariablesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoUnusedVariablesRule.js","sources":["../../../../../../../node_modules/graphql/validation/rules/NoUnusedVariablesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * No unused variables\n *\n * A GraphQL operation is only valid if all variables defined by an operation\n * are used, either directly or within a spread fragment.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variables-Used\n */\nexport function NoUnusedVariablesRule(context) {\n  let variableDefs = [];\n  return {\n    OperationDefinition: {\n      enter() {\n        variableDefs = [];\n      },\n\n      leave(operation) {\n        const variableNameUsed = Object.create(null);\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const { node } of usages) {\n          variableNameUsed[node.name.value] = true;\n        }\n\n        for (const variableDef of variableDefs) {\n          const variableName = variableDef.variable.name.value;\n\n          if (variableNameUsed[variableName] !== true) {\n            context.reportError(\n              new GraphQLError(\n                operation.name\n                  ? `Variable \"$${variableName}\" is never used in operation \"${operation.name.value}\".`\n                  : `Variable \"$${variableName}\" is never used.`,\n                {\n                  nodes: variableDef,\n                },\n              ),\n            );\n          }\n        }\n      },\n    },\n\n    VariableDefinition(def) {\n      variableDefs.push(def);\n    },\n  };\n}\n"],"names":[],"mappings":";AAUO,SAAS,sBAAsB,SAAS;AAC7C,MAAI,eAAe,CAAA;AACnB,SAAO;AAAA,IACL,qBAAqB;AAAA,MACnB,QAAQ;AACN,uBAAe,CAAA;AAAA,MAChB;AAAA,MAED,MAAM,WAAW;AACf,cAAM,mBAAmB,uBAAO,OAAO,IAAI;AAC3C,cAAM,SAAS,QAAQ,2BAA2B,SAAS;AAE3D,mBAAW,EAAE,KAAM,KAAI,QAAQ;AAC7B,2BAAiB,KAAK,KAAK,KAAK,IAAI;AAAA,QACrC;AAED,mBAAW,eAAe,cAAc;AACtC,gBAAM,eAAe,YAAY,SAAS,KAAK;AAE/C,cAAI,iBAAiB,YAAY,MAAM,MAAM;AAC3C,oBAAQ;AAAA,cACN,IAAI;AAAA,gBACF,UAAU,OACN,cAAc,6CAA6C,UAAU,KAAK,YAC1E,cAAc;AAAA,gBAClB;AAAA,kBACE,OAAO;AAAA,gBACR;AAAA,cACF;AAAA,YACf;AAAA,UACW;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IAED,mBAAmB,KAAK;AACtB,mBAAa,KAAK,GAAG;AAAA,IACtB;AAAA,EACL;AACA;"}

package/dist/__node_modules/graphql/validation/rules/OverlappingFieldsCanBeMergedRule.cjs

@@ -0,0 +1,477 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const inspect = require("../../jsutils/inspect.cjs");
+const GraphQLError = require("../../error/GraphQLError.cjs");
+const kinds = require("../../language/kinds.cjs");
+const printer = require("../../language/printer.cjs");
+const definition = require("../../type/definition.cjs");
+const sortValueNode = require("../../utilities/sortValueNode.cjs");
+const typeFromAST = require("../../utilities/typeFromAST.cjs");
+function reasonMessage(reason) {
+  if (Array.isArray(reason)) {
+    return reason.map(
+      ([responseName, subReason]) => `subfields "${responseName}" conflict because ` + reasonMessage(subReason)
+    ).join(" and ");
+  }
+  return reason;
+}
+function OverlappingFieldsCanBeMergedRule(context) {
+  const comparedFragmentPairs = new PairSet();
+  const cachedFieldsAndFragmentNames = /* @__PURE__ */ new Map();
+  return {
+    SelectionSet(selectionSet) {
+      const conflicts = findConflictsWithinSelectionSet(
+        context,
+        cachedFieldsAndFragmentNames,
+        comparedFragmentPairs,
+        context.getParentType(),
+        selectionSet
+      );
+      for (const [[responseName, reason], fields1, fields2] of conflicts) {
+        const reasonMsg = reasonMessage(reason);
+        context.reportError(
+          new GraphQLError.GraphQLError(
+            `Fields "${responseName}" conflict because ${reasonMsg}. Use different aliases on the fields to fetch both if this was intentional.`,
+            {
+              nodes: fields1.concat(fields2)
+            }
+          )
+        );
+      }
+    }
+  };
+}
+function findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentType, selectionSet) {
+  const conflicts = [];
+  const [fieldMap, fragmentNames] = getFieldsAndFragmentNames(
+    context,
+    cachedFieldsAndFragmentNames,
+    parentType,
+    selectionSet
+  );
+  collectConflictsWithin(
+    context,
+    conflicts,
+    cachedFieldsAndFragmentNames,
+    comparedFragmentPairs,
+    fieldMap
+  );
+  if (fragmentNames.length !== 0) {
+    for (let i = 0; i < fragmentNames.length; i++) {
+      collectConflictsBetweenFieldsAndFragment(
+        context,
+        conflicts,
+        cachedFieldsAndFragmentNames,
+        comparedFragmentPairs,
+        false,
+        fieldMap,
+        fragmentNames[i]
+      );
+      for (let j = i + 1; j < fragmentNames.length; j++) {
+        collectConflictsBetweenFragments(
+          context,
+          conflicts,
+          cachedFieldsAndFragmentNames,
+          comparedFragmentPairs,
+          false,
+          fragmentNames[i],
+          fragmentNames[j]
+        );
+      }
+    }
+  }
+  return conflicts;
+}
+function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentName) {
+  const fragment = context.getFragment(fragmentName);
+  if (!fragment) {
+    return;
+  }
+  const [fieldMap2, referencedFragmentNames] = getReferencedFieldsAndFragmentNames(
+    context,
+    cachedFieldsAndFragmentNames,
+    fragment
+  );
+  if (fieldMap === fieldMap2) {
+    return;
+  }
+  collectConflictsBetween(
+    context,
+    conflicts,
+    cachedFieldsAndFragmentNames,
+    comparedFragmentPairs,
+    areMutuallyExclusive,
+    fieldMap,
+    fieldMap2
+  );
+  for (const referencedFragmentName of referencedFragmentNames) {
+    if (comparedFragmentPairs.has(
+      referencedFragmentName,
+      fragmentName,
+      areMutuallyExclusive
+    )) {
+      continue;
+    }
+    comparedFragmentPairs.add(
+      referencedFragmentName,
+      fragmentName,
+      areMutuallyExclusive
+    );
+    collectConflictsBetweenFieldsAndFragment(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      fieldMap,
+      referencedFragmentName
+    );
+  }
+}
+function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentName1, fragmentName2) {
+  if (fragmentName1 === fragmentName2) {
+    return;
+  }
+  if (comparedFragmentPairs.has(
+    fragmentName1,
+    fragmentName2,
+    areMutuallyExclusive
+  )) {
+    return;
+  }
+  comparedFragmentPairs.add(fragmentName1, fragmentName2, areMutuallyExclusive);
+  const fragment1 = context.getFragment(fragmentName1);
+  const fragment2 = context.getFragment(fragmentName2);
+  if (!fragment1 || !fragment2) {
+    return;
+  }
+  const [fieldMap1, referencedFragmentNames1] = getReferencedFieldsAndFragmentNames(
+    context,
+    cachedFieldsAndFragmentNames,
+    fragment1
+  );
+  const [fieldMap2, referencedFragmentNames2] = getReferencedFieldsAndFragmentNames(
+    context,
+    cachedFieldsAndFragmentNames,
+    fragment2
+  );
+  collectConflictsBetween(
+    context,
+    conflicts,
+    cachedFieldsAndFragmentNames,
+    comparedFragmentPairs,
+    areMutuallyExclusive,
+    fieldMap1,
+    fieldMap2
+  );
+  for (const referencedFragmentName2 of referencedFragmentNames2) {
+    collectConflictsBetweenFragments(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      fragmentName1,
+      referencedFragmentName2
+    );
+  }
+  for (const referencedFragmentName1 of referencedFragmentNames1) {
+    collectConflictsBetweenFragments(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      referencedFragmentName1,
+      fragmentName2
+    );
+  }
+}
+function findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, parentType1, selectionSet1, parentType2, selectionSet2) {
+  const conflicts = [];
+  const [fieldMap1, fragmentNames1] = getFieldsAndFragmentNames(
+    context,
+    cachedFieldsAndFragmentNames,
+    parentType1,
+    selectionSet1
+  );
+  const [fieldMap2, fragmentNames2] = getFieldsAndFragmentNames(
+    context,
+    cachedFieldsAndFragmentNames,
+    parentType2,
+    selectionSet2
+  );
+  collectConflictsBetween(
+    context,
+    conflicts,
+    cachedFieldsAndFragmentNames,
+    comparedFragmentPairs,
+    areMutuallyExclusive,
+    fieldMap1,
+    fieldMap2
+  );
+  for (const fragmentName2 of fragmentNames2) {
+    collectConflictsBetweenFieldsAndFragment(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      fieldMap1,
+      fragmentName2
+    );
+  }
+  for (const fragmentName1 of fragmentNames1) {
+    collectConflictsBetweenFieldsAndFragment(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      fieldMap2,
+      fragmentName1
+    );
+  }
+  for (const fragmentName1 of fragmentNames1) {
+    for (const fragmentName2 of fragmentNames2) {
+      collectConflictsBetweenFragments(
+        context,
+        conflicts,
+        cachedFieldsAndFragmentNames,
+        comparedFragmentPairs,
+        areMutuallyExclusive,
+        fragmentName1,
+        fragmentName2
+      );
+    }
+  }
+  return conflicts;
+}
+function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, fieldMap) {
+  for (const [responseName, fields] of Object.entries(fieldMap)) {
+    if (fields.length > 1) {
+      for (let i = 0; i < fields.length; i++) {
+        for (let j = i + 1; j < fields.length; j++) {
+          const conflict = findConflict(
+            context,
+            cachedFieldsAndFragmentNames,
+            comparedFragmentPairs,
+            false,
+            // within one collection is never mutually exclusive
+            responseName,
+            fields[i],
+            fields[j]
+          );
+          if (conflict) {
+            conflicts.push(conflict);
+          }
+        }
+      }
+    }
+  }
+}
+function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, fieldMap1, fieldMap2) {
+  for (const [responseName, fields1] of Object.entries(fieldMap1)) {
+    const fields2 = fieldMap2[responseName];
+    if (fields2) {
+      for (const field1 of fields1) {
+        for (const field2 of fields2) {
+          const conflict = findConflict(
+            context,
+            cachedFieldsAndFragmentNames,
+            comparedFragmentPairs,
+            parentFieldsAreMutuallyExclusive,
+            responseName,
+            field1,
+            field2
+          );
+          if (conflict) {
+            conflicts.push(conflict);
+          }
+        }
+      }
+    }
+  }
+}
+function findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, responseName, field1, field2) {
+  const [parentType1, node1, def1] = field1;
+  const [parentType2, node2, def2] = field2;
+  const areMutuallyExclusive = parentFieldsAreMutuallyExclusive || parentType1 !== parentType2 && definition.isObjectType(parentType1) && definition.isObjectType(parentType2);
+  if (!areMutuallyExclusive) {
+    const name1 = node1.name.value;
+    const name2 = node2.name.value;
+    if (name1 !== name2) {
+      return [
+        [responseName, `"${name1}" and "${name2}" are different fields`],
+        [node1],
+        [node2]
+      ];
+    }
+    if (stringifyArguments(node1) !== stringifyArguments(node2)) {
+      return [
+        [responseName, "they have differing arguments"],
+        [node1],
+        [node2]
+      ];
+    }
+  }
+  const type1 = def1 === null || def1 === void 0 ? void 0 : def1.type;
+  const type2 = def2 === null || def2 === void 0 ? void 0 : def2.type;
+  if (type1 && type2 && doTypesConflict(type1, type2)) {
+    return [
+      [
+        responseName,
+        `they return conflicting types "${inspect.inspect(type1)}" and "${inspect.inspect(
+          type2
+        )}"`
+      ],
+      [node1],
+      [node2]
+    ];
+  }
+  const selectionSet1 = node1.selectionSet;
+  const selectionSet2 = node2.selectionSet;
+  if (selectionSet1 && selectionSet2) {
+    const conflicts = findConflictsBetweenSubSelectionSets(
+      context,
+      cachedFieldsAndFragmentNames,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      definition.getNamedType(type1),
+      selectionSet1,
+      definition.getNamedType(type2),
+      selectionSet2
+    );
+    return subfieldConflicts(conflicts, responseName, node1, node2);
+  }
+}
+function stringifyArguments(fieldNode) {
+  var _fieldNode$arguments;
+  const args = (_fieldNode$arguments = fieldNode.arguments) !== null && _fieldNode$arguments !== void 0 ? _fieldNode$arguments : [];
+  const inputObjectWithArgs = {
+    kind: kinds.Kind.OBJECT,
+    fields: args.map((argNode) => ({
+      kind: kinds.Kind.OBJECT_FIELD,
+      name: argNode.name,
+      value: argNode.value
+    }))
+  };
+  return printer.print(sortValueNode.sortValueNode(inputObjectWithArgs));
+}
+function doTypesConflict(type1, type2) {
+  if (definition.isListType(type1)) {
+    return definition.isListType(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
+  }
+  if (definition.isListType(type2)) {
+    return true;
+  }
+  if (definition.isNonNullType(type1)) {
+    return definition.isNonNullType(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
+  }
+  if (definition.isNonNullType(type2)) {
+    return true;
+  }
+  if (definition.isLeafType(type1) || definition.isLeafType(type2)) {
+    return type1 !== type2;
+  }
+  return false;
+}
+function getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet) {
+  const cached = cachedFieldsAndFragmentNames.get(selectionSet);
+  if (cached) {
+    return cached;
+  }
+  const nodeAndDefs = /* @__PURE__ */ Object.create(null);
+  const fragmentNames = /* @__PURE__ */ Object.create(null);
+  _collectFieldsAndFragmentNames(
+    context,
+    parentType,
+    selectionSet,
+    nodeAndDefs,
+    fragmentNames
+  );
+  const result = [nodeAndDefs, Object.keys(fragmentNames)];
+  cachedFieldsAndFragmentNames.set(selectionSet, result);
+  return result;
+}
+function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment) {
+  const cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);
+  if (cached) {
+    return cached;
+  }
+  const fragmentType = typeFromAST.typeFromAST(context.getSchema(), fragment.typeCondition);
+  return getFieldsAndFragmentNames(
+    context,
+    cachedFieldsAndFragmentNames,
+    fragmentType,
+    fragment.selectionSet
+  );
+}
+function _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames) {
+  for (const selection of selectionSet.selections) {
+    switch (selection.kind) {
+      case kinds.Kind.FIELD: {
+        const fieldName = selection.name.value;
+        let fieldDef;
+        if (definition.isObjectType(parentType) || definition.isInterfaceType(parentType)) {
+          fieldDef = parentType.getFields()[fieldName];
+        }
+        const responseName = selection.alias ? selection.alias.value : fieldName;
+        if (!nodeAndDefs[responseName]) {
+          nodeAndDefs[responseName] = [];
+        }
+        nodeAndDefs[responseName].push([parentType, selection, fieldDef]);
+        break;
+      }
+      case kinds.Kind.FRAGMENT_SPREAD:
+        fragmentNames[selection.name.value] = true;
+        break;
+      case kinds.Kind.INLINE_FRAGMENT: {
+        const typeCondition = selection.typeCondition;
+        const inlineFragmentType = typeCondition ? typeFromAST.typeFromAST(context.getSchema(), typeCondition) : parentType;
+        _collectFieldsAndFragmentNames(
+          context,
+          inlineFragmentType,
+          selection.selectionSet,
+          nodeAndDefs,
+          fragmentNames
+        );
+        break;
+      }
+    }
+  }
+}
+function subfieldConflicts(conflicts, responseName, node1, node2) {
+  if (conflicts.length > 0) {
+    return [
+      [responseName, conflicts.map(([reason]) => reason)],
+      [node1, ...conflicts.map(([, fields1]) => fields1).flat()],
+      [node2, ...conflicts.map(([, , fields2]) => fields2).flat()]
+    ];
+  }
+}
+class PairSet {
+  constructor() {
+    this._data = /* @__PURE__ */ new Map();
+  }
+  has(a, b, areMutuallyExclusive) {
+    var _this$_data$get;
+    const [key1, key2] = a < b ? [a, b] : [b, a];
+    const result = (_this$_data$get = this._data.get(key1)) === null || _this$_data$get === void 0 ? void 0 : _this$_data$get.get(key2);
+    if (result === void 0) {
+      return false;
+    }
+    return areMutuallyExclusive ? true : areMutuallyExclusive === result;
+  }
+  add(a, b, areMutuallyExclusive) {
+    const [key1, key2] = a < b ? [a, b] : [b, a];
+    const map = this._data.get(key1);
+    if (map === void 0) {
+      this._data.set(key1, /* @__PURE__ */ new Map([[key2, areMutuallyExclusive]]));
+    } else {
+      map.set(key2, areMutuallyExclusive);
+    }
+  }
+}
+exports.OverlappingFieldsCanBeMergedRule = OverlappingFieldsCanBeMergedRule;
+//# sourceMappingURL=OverlappingFieldsCanBeMergedRule.cjs.map

package/dist/__node_modules/graphql/validation/rules/OverlappingFieldsCanBeMergedRule.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverlappingFieldsCanBeMergedRule.cjs","sources":["../../../../../../../node_modules/graphql/validation/rules/OverlappingFieldsCanBeMergedRule.mjs"],"sourcesContent":["import { inspect } from '../../jsutils/inspect.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { print } from '../../language/printer.mjs';\nimport {\n  getNamedType,\n  isInterfaceType,\n  isLeafType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n} from '../../type/definition.mjs';\nimport { sortValueNode } from '../../utilities/sortValueNode.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\nfunction reasonMessage(reason) {\n  if (Array.isArray(reason)) {\n    return reason\n      .map(\n        ([responseName, subReason]) =>\n          `subfields \"${responseName}\" conflict because ` +\n          reasonMessage(subReason),\n      )\n      .join(' and ');\n  }\n\n  return reason;\n}\n/**\n * Overlapping fields can be merged\n *\n * A selection set is only valid if all fields (including spreading any\n * fragments) either correspond to distinct response names or can be merged\n * without ambiguity.\n *\n * See https://spec.graphql.org/draft/#sec-Field-Selection-Merging\n */\n\nexport function OverlappingFieldsCanBeMergedRule(context) {\n  // A memoization for when two fragments are compared \"between\" each other for\n  // conflicts. Two fragments may be compared many times, so memoizing this can\n  // dramatically improve the performance of this validator.\n  const comparedFragmentPairs = new PairSet(); // A cache for the \"field map\" and list of fragment names found in any given\n  // selection set. Selection sets may be asked for this information multiple\n  // times, so this improves the performance of this validator.\n\n  const cachedFieldsAndFragmentNames = new Map();\n  return {\n    SelectionSet(selectionSet) {\n      const conflicts = findConflictsWithinSelectionSet(\n        context,\n        cachedFieldsAndFragmentNames,\n        comparedFragmentPairs,\n        context.getParentType(),\n        selectionSet,\n      );\n\n      for (const [[responseName, reason], fields1, fields2] of conflicts) {\n        const reasonMsg = reasonMessage(reason);\n        context.reportError(\n          new GraphQLError(\n            `Fields \"${responseName}\" conflict because ${reasonMsg}. Use different aliases on the fields to fetch both if this was intentional.`,\n            {\n              nodes: fields1.concat(fields2),\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n\n/**\n * Algorithm:\n *\n * Conflicts occur when two fields exist in a query which will produce the same\n * response name, but represent differing values, thus creating a conflict.\n * The algorithm below finds all conflicts via making a series of comparisons\n * between fields. In order to compare as few fields as possible, this makes\n * a series of comparisons \"within\" sets of fields and \"between\" sets of fields.\n *\n * Given any selection set, a collection produces both a set of fields by\n * also including all inline fragments, as well as a list of fragments\n * referenced by fragment spreads.\n *\n * A) Each selection set represented in the document first compares \"within\" its\n * collected set of fields, finding any conflicts between every pair of\n * overlapping fields.\n * Note: This is the *only time* that a the fields \"within\" a set are compared\n * to each other. After this only fields \"between\" sets are compared.\n *\n * B) Also, if any fragment is referenced in a selection set, then a\n * comparison is made \"between\" the original set of fields and the\n * referenced fragment.\n *\n * C) Also, if multiple fragments are referenced, then comparisons\n * are made \"between\" each referenced fragment.\n *\n * D) When comparing \"between\" a set of fields and a referenced fragment, first\n * a comparison is made between each field in the original set of fields and\n * each field in the the referenced set of fields.\n *\n * E) Also, if any fragment is referenced in the referenced selection set,\n * then a comparison is made \"between\" the original set of fields and the\n * referenced fragment (recursively referring to step D).\n *\n * F) When comparing \"between\" two fragments, first a comparison is made between\n * each field in the first referenced set of fields and each field in the the\n * second referenced set of fields.\n *\n * G) Also, any fragments referenced by the first must be compared to the\n * second, and any fragments referenced by the second must be compared to the\n * first (recursively referring to step F).\n *\n * H) When comparing two fields, if both have selection sets, then a comparison\n * is made \"between\" both selection sets, first comparing the set of fields in\n * the first selection set with the set of fields in the second.\n *\n * I) Also, if any fragment is referenced in either selection set, then a\n * comparison is made \"between\" the other set of fields and the\n * referenced fragment.\n *\n * J) Also, if two fragments are referenced in both selection sets, then a\n * comparison is made \"between\" the two fragments.\n *\n */\n// Find all conflicts found \"within\" a selection set, including those found\n// via spreading in fragments. Called when visiting each SelectionSet in the\n// GraphQL Document.\nfunction findConflictsWithinSelectionSet(\n  context,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  parentType,\n  selectionSet,\n) {\n  const conflicts = [];\n  const [fieldMap, fragmentNames] = getFieldsAndFragmentNames(\n    context,\n    cachedFieldsAndFragmentNames,\n    parentType,\n    selectionSet,\n  ); // (A) Find find all conflicts \"within\" the fields of this selection set.\n  // Note: this is the *only place* `collectConflictsWithin` is called.\n\n  collectConflictsWithin(\n    context,\n    conflicts,\n    cachedFieldsAndFragmentNames,\n    comparedFragmentPairs,\n    fieldMap,\n  );\n\n  if (fragmentNames.length !== 0) {\n    // (B) Then collect conflicts between these fields and those represented by\n    // each spread fragment name found.\n    for (let i = 0; i < fragmentNames.length; i++) {\n      collectConflictsBetweenFieldsAndFragment(\n        context,\n        conflicts,\n        cachedFieldsAndFragmentNames,\n        comparedFragmentPairs,\n        false,\n        fieldMap,\n        fragmentNames[i],\n      ); // (C) Then compare this fragment with all other fragments found in this\n      // selection set to collect conflicts between fragments spread together.\n      // This compares each item in the list of fragment names to every other\n      // item in that same list (except for itself).\n\n      for (let j = i + 1; j < fragmentNames.length; j++) {\n        collectConflictsBetweenFragments(\n          context,\n          conflicts,\n          cachedFieldsAndFragmentNames,\n          comparedFragmentPairs,\n          false,\n          fragmentNames[i],\n          fragmentNames[j],\n        );\n      }\n    }\n  }\n\n  return conflicts;\n} // Collect all conflicts found between a set of fields and a fragment reference\n// including via spreading in any nested fragments.\n\nfunction collectConflictsBetweenFieldsAndFragment(\n  context,\n  conflicts,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  areMutuallyExclusive,\n  fieldMap,\n  fragmentName,\n) {\n  const fragment = context.getFragment(fragmentName);\n\n  if (!fragment) {\n    return;\n  }\n\n  const [fieldMap2, referencedFragmentNames] =\n    getReferencedFieldsAndFragmentNames(\n      context,\n      cachedFieldsAndFragmentNames,\n      fragment,\n    ); // Do not compare a fragment's fieldMap to itself.\n\n  if (fieldMap === fieldMap2) {\n    return;\n  } // (D) First collect any conflicts between the provided collection of fields\n  // and the collection of fields represented by the given fragment.\n\n  collectConflictsBetween(\n    context,\n    conflicts,\n    cachedFieldsAndFragmentNames,\n    comparedFragmentPairs,\n    areMutuallyExclusive,\n    fieldMap,\n    fieldMap2,\n  ); // (E) Then collect any conflicts between the provided collection of fields\n  // and any fragment names found in the given fragment.\n\n  for (const referencedFragmentName of referencedFragmentNames) {\n    // Memoize so two fragments are not compared for conflicts more than once.\n    if (\n      comparedFragmentPairs.has(\n        referencedFragmentName,\n        fragmentName,\n        areMutuallyExclusive,\n      )\n    ) {\n      continue;\n    }\n\n    comparedFragmentPairs.add(\n      referencedFragmentName,\n      fragmentName,\n      areMutuallyExclusive,\n    );\n    collectConflictsBetweenFieldsAndFragment(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      fieldMap,\n      referencedFragmentName,\n    );\n  }\n} // Collect all conflicts found between two fragments, including via spreading in\n// any nested fragments.\n\nfunction collectConflictsBetweenFragments(\n  context,\n  conflicts,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  areMutuallyExclusive,\n  fragmentName1,\n  fragmentName2,\n) {\n  // No need to compare a fragment to itself.\n  if (fragmentName1 === fragmentName2) {\n    return;\n  } // Memoize so two fragments are not compared for conflicts more than once.\n\n  if (\n    comparedFragmentPairs.has(\n      fragmentName1,\n      fragmentName2,\n      areMutuallyExclusive,\n    )\n  ) {\n    return;\n  }\n\n  comparedFragmentPairs.add(fragmentName1, fragmentName2, areMutuallyExclusive);\n  const fragment1 = context.getFragment(fragmentName1);\n  const fragment2 = context.getFragment(fragmentName2);\n\n  if (!fragment1 || !fragment2) {\n    return;\n  }\n\n  const [fieldMap1, referencedFragmentNames1] =\n    getReferencedFieldsAndFragmentNames(\n      context,\n      cachedFieldsAndFragmentNames,\n      fragment1,\n    );\n  const [fieldMap2, referencedFragmentNames2] =\n    getReferencedFieldsAndFragmentNames(\n      context,\n      cachedFieldsAndFragmentNames,\n      fragment2,\n    ); // (F) First, collect all conflicts between these two collections of fields\n  // (not including any nested fragments).\n\n  collectConflictsBetween(\n    context,\n    conflicts,\n    cachedFieldsAndFragmentNames,\n    comparedFragmentPairs,\n    areMutuallyExclusive,\n    fieldMap1,\n    fieldMap2,\n  ); // (G) Then collect conflicts between the first fragment and any nested\n  // fragments spread in the second fragment.\n\n  for (const referencedFragmentName2 of referencedFragmentNames2) {\n    collectConflictsBetweenFragments(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      fragmentName1,\n      referencedFragmentName2,\n    );\n  } // (G) Then collect conflicts between the second fragment and any nested\n  // fragments spread in the first fragment.\n\n  for (const referencedFragmentName1 of referencedFragmentNames1) {\n    collectConflictsBetweenFragments(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      referencedFragmentName1,\n      fragmentName2,\n    );\n  }\n} // Find all conflicts found between two selection sets, including those found\n// via spreading in fragments. Called when determining if conflicts exist\n// between the sub-fields of two overlapping fields.\n\nfunction findConflictsBetweenSubSelectionSets(\n  context,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  areMutuallyExclusive,\n  parentType1,\n  selectionSet1,\n  parentType2,\n  selectionSet2,\n) {\n  const conflicts = [];\n  const [fieldMap1, fragmentNames1] = getFieldsAndFragmentNames(\n    context,\n    cachedFieldsAndFragmentNames,\n    parentType1,\n    selectionSet1,\n  );\n  const [fieldMap2, fragmentNames2] = getFieldsAndFragmentNames(\n    context,\n    cachedFieldsAndFragmentNames,\n    parentType2,\n    selectionSet2,\n  ); // (H) First, collect all conflicts between these two collections of field.\n\n  collectConflictsBetween(\n    context,\n    conflicts,\n    cachedFieldsAndFragmentNames,\n    comparedFragmentPairs,\n    areMutuallyExclusive,\n    fieldMap1,\n    fieldMap2,\n  ); // (I) Then collect conflicts between the first collection of fields and\n  // those referenced by each fragment name associated with the second.\n\n  for (const fragmentName2 of fragmentNames2) {\n    collectConflictsBetweenFieldsAndFragment(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      fieldMap1,\n      fragmentName2,\n    );\n  } // (I) Then collect conflicts between the second collection of fields and\n  // those referenced by each fragment name associated with the first.\n\n  for (const fragmentName1 of fragmentNames1) {\n    collectConflictsBetweenFieldsAndFragment(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      fieldMap2,\n      fragmentName1,\n    );\n  } // (J) Also collect conflicts between any fragment names by the first and\n  // fragment names by the second. This compares each item in the first set of\n  // names to each item in the second set of names.\n\n  for (const fragmentName1 of fragmentNames1) {\n    for (const fragmentName2 of fragmentNames2) {\n      collectConflictsBetweenFragments(\n        context,\n        conflicts,\n        cachedFieldsAndFragmentNames,\n        comparedFragmentPairs,\n        areMutuallyExclusive,\n        fragmentName1,\n        fragmentName2,\n      );\n    }\n  }\n\n  return conflicts;\n} // Collect all Conflicts \"within\" one collection of fields.\n\nfunction collectConflictsWithin(\n  context,\n  conflicts,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  fieldMap,\n) {\n  // A field map is a keyed collection, where each key represents a response\n  // name and the value at that key is a list of all fields which provide that\n  // response name. For every response name, if there are multiple fields, they\n  // must be compared to find a potential conflict.\n  for (const [responseName, fields] of Object.entries(fieldMap)) {\n    // This compares every field in the list to every other field in this list\n    // (except to itself). If the list only has one item, nothing needs to\n    // be compared.\n    if (fields.length > 1) {\n      for (let i = 0; i < fields.length; i++) {\n        for (let j = i + 1; j < fields.length; j++) {\n          const conflict = findConflict(\n            context,\n            cachedFieldsAndFragmentNames,\n            comparedFragmentPairs,\n            false, // within one collection is never mutually exclusive\n            responseName,\n            fields[i],\n            fields[j],\n          );\n\n          if (conflict) {\n            conflicts.push(conflict);\n          }\n        }\n      }\n    }\n  }\n} // Collect all Conflicts between two collections of fields. This is similar to,\n// but different from the `collectConflictsWithin` function above. This check\n// assumes that `collectConflictsWithin` has already been called on each\n// provided collection of fields. This is true because this validator traverses\n// each individual selection set.\n\nfunction collectConflictsBetween(\n  context,\n  conflicts,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  parentFieldsAreMutuallyExclusive,\n  fieldMap1,\n  fieldMap2,\n) {\n  // A field map is a keyed collection, where each key represents a response\n  // name and the value at that key is a list of all fields which provide that\n  // response name. For any response name which appears in both provided field\n  // maps, each field from the first field map must be compared to every field\n  // in the second field map to find potential conflicts.\n  for (const [responseName, fields1] of Object.entries(fieldMap1)) {\n    const fields2 = fieldMap2[responseName];\n\n    if (fields2) {\n      for (const field1 of fields1) {\n        for (const field2 of fields2) {\n          const conflict = findConflict(\n            context,\n            cachedFieldsAndFragmentNames,\n            comparedFragmentPairs,\n            parentFieldsAreMutuallyExclusive,\n            responseName,\n            field1,\n            field2,\n          );\n\n          if (conflict) {\n            conflicts.push(conflict);\n          }\n        }\n      }\n    }\n  }\n} // Determines if there is a conflict between two particular fields, including\n// comparing their sub-fields.\n\nfunction findConflict(\n  context,\n  cachedFieldsAndFragmentNames,\n  comparedFragmentPairs,\n  parentFieldsAreMutuallyExclusive,\n  responseName,\n  field1,\n  field2,\n) {\n  const [parentType1, node1, def1] = field1;\n  const [parentType2, node2, def2] = field2; // If it is known that two fields could not possibly apply at the same\n  // time, due to the parent types, then it is safe to permit them to diverge\n  // in aliased field or arguments used as they will not present any ambiguity\n  // by differing.\n  // It is known that two parent types could never overlap if they are\n  // different Object types. Interface or Union types might overlap - if not\n  // in the current state of the schema, then perhaps in some future version,\n  // thus may not safely diverge.\n\n  const areMutuallyExclusive =\n    parentFieldsAreMutuallyExclusive ||\n    (parentType1 !== parentType2 &&\n      isObjectType(parentType1) &&\n      isObjectType(parentType2));\n\n  if (!areMutuallyExclusive) {\n    // Two aliases must refer to the same field.\n    const name1 = node1.name.value;\n    const name2 = node2.name.value;\n\n    if (name1 !== name2) {\n      return [\n        [responseName, `\"${name1}\" and \"${name2}\" are different fields`],\n        [node1],\n        [node2],\n      ];\n    } // Two field calls must have the same arguments.\n\n    if (stringifyArguments(node1) !== stringifyArguments(node2)) {\n      return [\n        [responseName, 'they have differing arguments'],\n        [node1],\n        [node2],\n      ];\n    }\n  } // The return type for each field.\n\n  const type1 = def1 === null || def1 === void 0 ? void 0 : def1.type;\n  const type2 = def2 === null || def2 === void 0 ? void 0 : def2.type;\n\n  if (type1 && type2 && doTypesConflict(type1, type2)) {\n    return [\n      [\n        responseName,\n        `they return conflicting types \"${inspect(type1)}\" and \"${inspect(\n          type2,\n        )}\"`,\n      ],\n      [node1],\n      [node2],\n    ];\n  } // Collect and compare sub-fields. Use the same \"visited fragment names\" list\n  // for both collections so fields in a fragment reference are never\n  // compared to themselves.\n\n  const selectionSet1 = node1.selectionSet;\n  const selectionSet2 = node2.selectionSet;\n\n  if (selectionSet1 && selectionSet2) {\n    const conflicts = findConflictsBetweenSubSelectionSets(\n      context,\n      cachedFieldsAndFragmentNames,\n      comparedFragmentPairs,\n      areMutuallyExclusive,\n      getNamedType(type1),\n      selectionSet1,\n      getNamedType(type2),\n      selectionSet2,\n    );\n    return subfieldConflicts(conflicts, responseName, node1, node2);\n  }\n}\n\nfunction stringifyArguments(fieldNode) {\n  var _fieldNode$arguments;\n\n  // FIXME https://github.com/graphql/graphql-js/issues/2203\n  const args =\n    /* c8 ignore next */\n    (_fieldNode$arguments = fieldNode.arguments) !== null &&\n    _fieldNode$arguments !== void 0\n      ? _fieldNode$arguments\n      : [];\n  const inputObjectWithArgs = {\n    kind: Kind.OBJECT,\n    fields: args.map((argNode) => ({\n      kind: Kind.OBJECT_FIELD,\n      name: argNode.name,\n      value: argNode.value,\n    })),\n  };\n  return print(sortValueNode(inputObjectWithArgs));\n} // Two types conflict if both types could not apply to a value simultaneously.\n// Composite types are ignored as their individual field types will be compared\n// later recursively. However List and Non-Null types must match.\n\nfunction doTypesConflict(type1, type2) {\n  if (isListType(type1)) {\n    return isListType(type2)\n      ? doTypesConflict(type1.ofType, type2.ofType)\n      : true;\n  }\n\n  if (isListType(type2)) {\n    return true;\n  }\n\n  if (isNonNullType(type1)) {\n    return isNonNullType(type2)\n      ? doTypesConflict(type1.ofType, type2.ofType)\n      : true;\n  }\n\n  if (isNonNullType(type2)) {\n    return true;\n  }\n\n  if (isLeafType(type1) || isLeafType(type2)) {\n    return type1 !== type2;\n  }\n\n  return false;\n} // Given a selection set, return the collection of fields (a mapping of response\n// name to field nodes and definitions) as well as a list of fragment names\n// referenced via fragment spreads.\n\nfunction getFieldsAndFragmentNames(\n  context,\n  cachedFieldsAndFragmentNames,\n  parentType,\n  selectionSet,\n) {\n  const cached = cachedFieldsAndFragmentNames.get(selectionSet);\n\n  if (cached) {\n    return cached;\n  }\n\n  const nodeAndDefs = Object.create(null);\n  const fragmentNames = Object.create(null);\n\n  _collectFieldsAndFragmentNames(\n    context,\n    parentType,\n    selectionSet,\n    nodeAndDefs,\n    fragmentNames,\n  );\n\n  const result = [nodeAndDefs, Object.keys(fragmentNames)];\n  cachedFieldsAndFragmentNames.set(selectionSet, result);\n  return result;\n} // Given a reference to a fragment, return the represented collection of fields\n// as well as a list of nested fragment names referenced via fragment spreads.\n\nfunction getReferencedFieldsAndFragmentNames(\n  context,\n  cachedFieldsAndFragmentNames,\n  fragment,\n) {\n  // Short-circuit building a type from the node if possible.\n  const cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);\n\n  if (cached) {\n    return cached;\n  }\n\n  const fragmentType = typeFromAST(context.getSchema(), fragment.typeCondition);\n  return getFieldsAndFragmentNames(\n    context,\n    cachedFieldsAndFragmentNames,\n    fragmentType,\n    fragment.selectionSet,\n  );\n}\n\nfunction _collectFieldsAndFragmentNames(\n  context,\n  parentType,\n  selectionSet,\n  nodeAndDefs,\n  fragmentNames,\n) {\n  for (const selection of selectionSet.selections) {\n    switch (selection.kind) {\n      case Kind.FIELD: {\n        const fieldName = selection.name.value;\n        let fieldDef;\n\n        if (isObjectType(parentType) || isInterfaceType(parentType)) {\n          fieldDef = parentType.getFields()[fieldName];\n        }\n\n        const responseName = selection.alias\n          ? selection.alias.value\n          : fieldName;\n\n        if (!nodeAndDefs[responseName]) {\n          nodeAndDefs[responseName] = [];\n        }\n\n        nodeAndDefs[responseName].push([parentType, selection, fieldDef]);\n        break;\n      }\n\n      case Kind.FRAGMENT_SPREAD:\n        fragmentNames[selection.name.value] = true;\n        break;\n\n      case Kind.INLINE_FRAGMENT: {\n        const typeCondition = selection.typeCondition;\n        const inlineFragmentType = typeCondition\n          ? typeFromAST(context.getSchema(), typeCondition)\n          : parentType;\n\n        _collectFieldsAndFragmentNames(\n          context,\n          inlineFragmentType,\n          selection.selectionSet,\n          nodeAndDefs,\n          fragmentNames,\n        );\n\n        break;\n      }\n    }\n  }\n} // Given a series of Conflicts which occurred between two sub-fields, generate\n// a single Conflict.\n\nfunction subfieldConflicts(conflicts, responseName, node1, node2) {\n  if (conflicts.length > 0) {\n    return [\n      [responseName, conflicts.map(([reason]) => reason)],\n      [node1, ...conflicts.map(([, fields1]) => fields1).flat()],\n      [node2, ...conflicts.map(([, , fields2]) => fields2).flat()],\n    ];\n  }\n}\n/**\n * A way to keep track of pairs of things when the ordering of the pair does not matter.\n */\n\nclass PairSet {\n  constructor() {\n    this._data = new Map();\n  }\n\n  has(a, b, areMutuallyExclusive) {\n    var _this$_data$get;\n\n    const [key1, key2] = a < b ? [a, b] : [b, a];\n    const result =\n      (_this$_data$get = this._data.get(key1)) === null ||\n      _this$_data$get === void 0\n        ? void 0\n        : _this$_data$get.get(key2);\n\n    if (result === undefined) {\n      return false;\n    } // areMutuallyExclusive being false is a superset of being true, hence if\n    // we want to know if this PairSet \"has\" these two with no exclusivity,\n    // we have to ensure it was added as such.\n\n    return areMutuallyExclusive ? true : areMutuallyExclusive === result;\n  }\n\n  add(a, b, areMutuallyExclusive) {\n    const [key1, key2] = a < b ? [a, b] : [b, a];\n\n    const map = this._data.get(key1);\n\n    if (map === undefined) {\n      this._data.set(key1, new Map([[key2, areMutuallyExclusive]]));\n    } else {\n      map.set(key2, areMutuallyExclusive);\n    }\n  }\n}\n"],"names":["GraphQLError","isObjectType","inspect","getNamedType","Kind","print","sortValueNode","isListType","isNonNullType","isLeafType","typeFromAST","isInterfaceType"],"mappings":"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"}