@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/graphql/validation/rules/OverlappingFieldsCanBeMergedRule.js

@@ -0,0 +1,519 @@
+import { inspect } from "../../jsutils/inspect.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { Kind } from "../../language/kinds.js";
+import { print } from "../../language/printer.js";
+import { isObjectType, isInterfaceType, getNamedType, isListType, isNonNullType, isLeafType } from "../../type/definition.js";
+import { sortValueNode } from "../../utilities/sortValueNode.js";
+import { typeFromAST } from "../../utilities/typeFromAST.js";
+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 comparedFieldsAndFragmentPairs = new OrderedPairSet();
+  const comparedFragmentPairs = new PairSet();
+  const cachedFieldsAndFragmentNames = /* @__PURE__ */ new Map();
+  return {
+    SelectionSet(selectionSet) {
+      const conflicts = findConflictsWithinSelectionSet(
+        context,
+        cachedFieldsAndFragmentNames,
+        comparedFieldsAndFragmentPairs,
+        comparedFragmentPairs,
+        context.getParentType(),
+        selectionSet
+      );
+      for (const [[responseName, reason], fields1, fields2] of conflicts) {
+        const reasonMsg = reasonMessage(reason);
+        context.reportError(
+          new 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, comparedFieldsAndFragmentPairs, comparedFragmentPairs, parentType, selectionSet) {
+  const conflicts = [];
+  const [fieldMap, fragmentNames] = getFieldsAndFragmentNames(
+    context,
+    cachedFieldsAndFragmentNames,
+    parentType,
+    selectionSet
+  );
+  collectConflictsWithin(
+    context,
+    conflicts,
+    cachedFieldsAndFragmentNames,
+    comparedFieldsAndFragmentPairs,
+    comparedFragmentPairs,
+    fieldMap
+  );
+  if (fragmentNames.length !== 0) {
+    for (let i = 0; i < fragmentNames.length; i++) {
+      collectConflictsBetweenFieldsAndFragment(
+        context,
+        conflicts,
+        cachedFieldsAndFragmentNames,
+        comparedFieldsAndFragmentPairs,
+        comparedFragmentPairs,
+        false,
+        fieldMap,
+        fragmentNames[i]
+      );
+      for (let j = i + 1; j < fragmentNames.length; j++) {
+        collectConflictsBetweenFragments(
+          context,
+          conflicts,
+          cachedFieldsAndFragmentNames,
+          comparedFieldsAndFragmentPairs,
+          comparedFragmentPairs,
+          false,
+          fragmentNames[i],
+          fragmentNames[j]
+        );
+      }
+    }
+  }
+  return conflicts;
+}
+function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFieldsAndFragmentPairs, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentName) {
+  if (comparedFieldsAndFragmentPairs.has(
+    fieldMap,
+    fragmentName,
+    areMutuallyExclusive
+  )) {
+    return;
+  }
+  comparedFieldsAndFragmentPairs.add(
+    fieldMap,
+    fragmentName,
+    areMutuallyExclusive
+  );
+  const fragment = context.getFragment(fragmentName);
+  if (!fragment) {
+    return;
+  }
+  const [fieldMap2, referencedFragmentNames] = getReferencedFieldsAndFragmentNames(
+    context,
+    cachedFieldsAndFragmentNames,
+    fragment
+  );
+  if (fieldMap === fieldMap2) {
+    return;
+  }
+  collectConflictsBetween(
+    context,
+    conflicts,
+    cachedFieldsAndFragmentNames,
+    comparedFieldsAndFragmentPairs,
+    comparedFragmentPairs,
+    areMutuallyExclusive,
+    fieldMap,
+    fieldMap2
+  );
+  for (const referencedFragmentName of referencedFragmentNames) {
+    collectConflictsBetweenFieldsAndFragment(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFieldsAndFragmentPairs,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      fieldMap,
+      referencedFragmentName
+    );
+  }
+}
+function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFieldsAndFragmentPairs, 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,
+    comparedFieldsAndFragmentPairs,
+    comparedFragmentPairs,
+    areMutuallyExclusive,
+    fieldMap1,
+    fieldMap2
+  );
+  for (const referencedFragmentName2 of referencedFragmentNames2) {
+    collectConflictsBetweenFragments(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFieldsAndFragmentPairs,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      fragmentName1,
+      referencedFragmentName2
+    );
+  }
+  for (const referencedFragmentName1 of referencedFragmentNames1) {
+    collectConflictsBetweenFragments(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFieldsAndFragmentPairs,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      referencedFragmentName1,
+      fragmentName2
+    );
+  }
+}
+function findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFieldsAndFragmentPairs, 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,
+    comparedFieldsAndFragmentPairs,
+    comparedFragmentPairs,
+    areMutuallyExclusive,
+    fieldMap1,
+    fieldMap2
+  );
+  for (const fragmentName2 of fragmentNames2) {
+    collectConflictsBetweenFieldsAndFragment(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFieldsAndFragmentPairs,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      fieldMap1,
+      fragmentName2
+    );
+  }
+  for (const fragmentName1 of fragmentNames1) {
+    collectConflictsBetweenFieldsAndFragment(
+      context,
+      conflicts,
+      cachedFieldsAndFragmentNames,
+      comparedFieldsAndFragmentPairs,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      fieldMap2,
+      fragmentName1
+    );
+  }
+  for (const fragmentName1 of fragmentNames1) {
+    for (const fragmentName2 of fragmentNames2) {
+      collectConflictsBetweenFragments(
+        context,
+        conflicts,
+        cachedFieldsAndFragmentNames,
+        comparedFieldsAndFragmentPairs,
+        comparedFragmentPairs,
+        areMutuallyExclusive,
+        fragmentName1,
+        fragmentName2
+      );
+    }
+  }
+  return conflicts;
+}
+function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFieldsAndFragmentPairs, 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,
+            comparedFieldsAndFragmentPairs,
+            comparedFragmentPairs,
+            false,
+            // within one collection is never mutually exclusive
+            responseName,
+            fields[i],
+            fields[j]
+          );
+          if (conflict) {
+            conflicts.push(conflict);
+          }
+        }
+      }
+    }
+  }
+}
+function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFieldsAndFragmentPairs, 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,
+            comparedFieldsAndFragmentPairs,
+            comparedFragmentPairs,
+            parentFieldsAreMutuallyExclusive,
+            responseName,
+            field1,
+            field2
+          );
+          if (conflict) {
+            conflicts.push(conflict);
+          }
+        }
+      }
+    }
+  }
+}
+function findConflict(context, cachedFieldsAndFragmentNames, comparedFieldsAndFragmentPairs, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, responseName, field1, field2) {
+  const [parentType1, node1, def1] = field1;
+  const [parentType2, node2, def2] = field2;
+  const areMutuallyExclusive = parentFieldsAreMutuallyExclusive || parentType1 !== parentType2 && isObjectType(parentType1) && 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 (!sameArguments(node1, 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(type1)}" and "${inspect(
+          type2
+        )}"`
+      ],
+      [node1],
+      [node2]
+    ];
+  }
+  const selectionSet1 = node1.selectionSet;
+  const selectionSet2 = node2.selectionSet;
+  if (selectionSet1 && selectionSet2) {
+    const conflicts = findConflictsBetweenSubSelectionSets(
+      context,
+      cachedFieldsAndFragmentNames,
+      comparedFieldsAndFragmentPairs,
+      comparedFragmentPairs,
+      areMutuallyExclusive,
+      getNamedType(type1),
+      selectionSet1,
+      getNamedType(type2),
+      selectionSet2
+    );
+    return subfieldConflicts(conflicts, responseName, node1, node2);
+  }
+}
+function sameArguments(node1, node2) {
+  const args1 = node1.arguments;
+  const args2 = node2.arguments;
+  if (args1 === void 0 || args1.length === 0) {
+    return args2 === void 0 || args2.length === 0;
+  }
+  if (args2 === void 0 || args2.length === 0) {
+    return false;
+  }
+  if (args1.length !== args2.length) {
+    return false;
+  }
+  const values2 = new Map(args2.map(({ name, value }) => [name.value, value]));
+  return args1.every((arg1) => {
+    const value1 = arg1.value;
+    const value2 = values2.get(arg1.name.value);
+    if (value2 === void 0) {
+      return false;
+    }
+    return stringifyValue(value1) === stringifyValue(value2);
+  });
+}
+function stringifyValue(value) {
+  return print(sortValueNode(value));
+}
+function doTypesConflict(type1, type2) {
+  if (isListType(type1)) {
+    return isListType(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
+  }
+  if (isListType(type2)) {
+    return true;
+  }
+  if (isNonNullType(type1)) {
+    return isNonNullType(type2) ? doTypesConflict(type1.ofType, type2.ofType) : true;
+  }
+  if (isNonNullType(type2)) {
+    return true;
+  }
+  if (isLeafType(type1) || 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(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 Kind.FIELD: {
+        const fieldName = selection.name.value;
+        let fieldDef;
+        if (isObjectType(parentType) || 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 Kind.FRAGMENT_SPREAD:
+        fragmentNames[selection.name.value] = true;
+        break;
+      case Kind.INLINE_FRAGMENT: {
+        const typeCondition = selection.typeCondition;
+        const inlineFragmentType = typeCondition ? 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 OrderedPairSet {
+  constructor() {
+    this._data = /* @__PURE__ */ new Map();
+  }
+  has(a, b, weaklyPresent) {
+    var _this$_data$get;
+    const result = (_this$_data$get = this._data.get(a)) === null || _this$_data$get === void 0 ? void 0 : _this$_data$get.get(b);
+    if (result === void 0) {
+      return false;
+    }
+    return weaklyPresent ? true : weaklyPresent === result;
+  }
+  add(a, b, weaklyPresent) {
+    const map = this._data.get(a);
+    if (map === void 0) {
+      this._data.set(a, /* @__PURE__ */ new Map([[b, weaklyPresent]]));
+    } else {
+      map.set(b, weaklyPresent);
+    }
+  }
+}
+class PairSet {
+  constructor() {
+    this._orderedPairSet = new OrderedPairSet();
+  }
+  has(a, b, weaklyPresent) {
+    return a < b ? this._orderedPairSet.has(a, b, weaklyPresent) : this._orderedPairSet.has(b, a, weaklyPresent);
+  }
+  add(a, b, weaklyPresent) {
+    if (a < b) {
+      this._orderedPairSet.add(a, b, weaklyPresent);
+    } else {
+      this._orderedPairSet.add(b, a, weaklyPresent);
+    }
+  }
+}
+export {
+  OverlappingFieldsCanBeMergedRule
+};
+//# sourceMappingURL=OverlappingFieldsCanBeMergedRule.js.map

package/dist/node_modules/graphql/validation/rules/OverlappingFieldsCanBeMergedRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverlappingFieldsCanBeMergedRule.js","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 fields and a fragment or two fragments are compared\n  // \"between\" each other for conflicts. Comparisons made be made many times,\n  // so memoizing this can dramatically improve the performance of this validator.\n  const comparedFieldsAndFragmentPairs = new OrderedPairSet();\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        comparedFieldsAndFragmentPairs,\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  comparedFieldsAndFragmentPairs,\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    comparedFieldsAndFragmentPairs,\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        comparedFieldsAndFragmentPairs,\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          comparedFieldsAndFragmentPairs,\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  comparedFieldsAndFragmentPairs,\n  comparedFragmentPairs,\n  areMutuallyExclusive,\n  fieldMap,\n  fragmentName,\n) {\n  // Memoize so the fields and fragments are not compared for conflicts more\n  // than once.\n  if (\n    comparedFieldsAndFragmentPairs.has(\n      fieldMap,\n      fragmentName,\n      areMutuallyExclusive,\n    )\n  ) {\n    return;\n  }\n\n  comparedFieldsAndFragmentPairs.add(\n    fieldMap,\n    fragmentName,\n    areMutuallyExclusive,\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    comparedFieldsAndFragmentPairs,\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    collectConflictsBetweenFieldsAndFragment(\n      context,\n      conflicts,\n      cachedFieldsAndFragmentNames,\n      comparedFieldsAndFragmentPairs,\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  comparedFieldsAndFragmentPairs,\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    comparedFieldsAndFragmentPairs,\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      comparedFieldsAndFragmentPairs,\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      comparedFieldsAndFragmentPairs,\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  comparedFieldsAndFragmentPairs,\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    comparedFieldsAndFragmentPairs,\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      comparedFieldsAndFragmentPairs,\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      comparedFieldsAndFragmentPairs,\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        comparedFieldsAndFragmentPairs,\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  comparedFieldsAndFragmentPairs,\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            comparedFieldsAndFragmentPairs,\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  comparedFieldsAndFragmentPairs,\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            comparedFieldsAndFragmentPairs,\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  comparedFieldsAndFragmentPairs,\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 (!sameArguments(node1, 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      comparedFieldsAndFragmentPairs,\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 sameArguments(node1, node2) {\n  const args1 = node1.arguments;\n  const args2 = node2.arguments;\n\n  if (args1 === undefined || args1.length === 0) {\n    return args2 === undefined || args2.length === 0;\n  }\n\n  if (args2 === undefined || args2.length === 0) {\n    return false;\n  }\n  /* c8 ignore next */\n\n  if (args1.length !== args2.length) {\n    /* c8 ignore next */\n    return false;\n    /* c8 ignore next */\n  }\n\n  const values2 = new Map(args2.map(({ name, value }) => [name.value, value]));\n  return args1.every((arg1) => {\n    const value1 = arg1.value;\n    const value2 = values2.get(arg1.name.value);\n\n    if (value2 === undefined) {\n      return false;\n    }\n\n    return stringifyValue(value1) === stringifyValue(value2);\n  });\n}\n\nfunction stringifyValue(value) {\n  return print(sortValueNode(value));\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 where the ordering of the pair\n * matters.\n *\n * Provides a third argument for has/set to allow flagging the pair as\n * weakly or strongly present within the collection.\n */\n\nclass OrderedPairSet {\n  constructor() {\n    this._data = new Map();\n  }\n\n  has(a, b, weaklyPresent) {\n    var _this$_data$get;\n\n    const result =\n      (_this$_data$get = this._data.get(a)) === null ||\n      _this$_data$get === void 0\n        ? void 0\n        : _this$_data$get.get(b);\n\n    if (result === undefined) {\n      return false;\n    }\n\n    return weaklyPresent ? true : weaklyPresent === result;\n  }\n\n  add(a, b, weaklyPresent) {\n    const map = this._data.get(a);\n\n    if (map === undefined) {\n      this._data.set(a, new Map([[b, weaklyPresent]]));\n    } else {\n      map.set(b, weaklyPresent);\n    }\n  }\n}\n/**\n * A way to keep track of pairs of similar things when the ordering of the pair\n * does not matter.\n */\n\nclass PairSet {\n  constructor() {\n    this._orderedPairSet = new OrderedPairSet();\n  }\n\n  has(a, b, weaklyPresent) {\n    return a < b\n      ? this._orderedPairSet.has(a, b, weaklyPresent)\n      : this._orderedPairSet.has(b, a, weaklyPresent);\n  }\n\n  add(a, b, weaklyPresent) {\n    if (a < b) {\n      this._orderedPairSet.add(a, b, weaklyPresent);\n    } else {\n      this._orderedPairSet.add(b, a, weaklyPresent);\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;;;AAeA,SAAS,cAAc,QAAQ;AAC7B,MAAI,MAAM,QAAQ,MAAM,GAAG;AACzB,WAAO,OACJ;AAAA,MACC,CAAC,CAAC,cAAc,SAAS,MACvB,cAAc,YAAY,wBAC1B,cAAc,SAAS;AAAA,IACjC,EACO,KAAK,OAAO;AAAA,EACjB;AAEA,SAAO;AACT;AAWO,SAAS,iCAAiC,SAAS;AAIxD,QAAM,iCAAiC,IAAI,eAAc;AACzD,QAAM,wBAAwB,IAAI;AAIlC,QAAM,+BAA+B,oBAAI,IAAG;AAC5C,SAAO;AAAA,IACL,aAAa,cAAc;AACzB,YAAM,YAAY;AAAA,QAChB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,QAAQ,cAAa;AAAA,QACrB;AAAA,MACR;AAEM,iBAAW,CAAC,CAAC,cAAc,MAAM,GAAG,SAAS,OAAO,KAAK,WAAW;AAClE,cAAM,YAAY,cAAc,MAAM;AACtC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,WAAW,YAAY,sBAAsB,SAAS;AAAA,YACtD;AAAA,cACE,OAAO,QAAQ,OAAO,OAAO;AAAA,YAC3C;AAAA,UACA;AAAA,QACA;AAAA,MACM;AAAA,IACF;AAAA,EACJ;AACA;AA2DA,SAAS,gCACP,SACA,8BACA,gCACA,uBACA,YACA,cACA;AACA,QAAM,YAAY,CAAA;AAClB,QAAM,CAAC,UAAU,aAAa,IAAI;AAAA,IAChC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AAGE;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AAEE,MAAI,cAAc,WAAW,GAAG;AAG9B,aAAS,IAAI,GAAG,IAAI,cAAc,QAAQ,KAAK;AAC7C;AAAA,QACE;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,cAAc,CAAC;AAAA,MACvB;AAKM,eAAS,IAAI,IAAI,GAAG,IAAI,cAAc,QAAQ,KAAK;AACjD;AAAA,UACE;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA,cAAc,CAAC;AAAA,UACf,cAAc,CAAC;AAAA,QACzB;AAAA,MACM;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAGA,SAAS,yCACP,SACA,WACA,8BACA,gCACA,uBACA,sBACA,UACA,cACA;AAGA,MACE,+BAA+B;AAAA,IAC7B;AAAA,IACA;AAAA,IACA;AAAA,EACN,GACI;AACA;AAAA,EACF;AAEA,iCAA+B;AAAA,IAC7B;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AACE,QAAM,WAAW,QAAQ,YAAY,YAAY;AAEjD,MAAI,CAAC,UAAU;AACb;AAAA,EACF;AAEA,QAAM,CAAC,WAAW,uBAAuB,IACvC;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,EACN;AAEE,MAAI,aAAa,WAAW;AAC1B;AAAA,EACF;AAGA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AAGE,aAAW,0BAA0B,yBAAyB;AAC5D;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACN;AAAA,EACE;AACF;AAGA,SAAS,iCACP,SACA,WACA,8BACA,gCACA,uBACA,sBACA,eACA,eACA;AAEA,MAAI,kBAAkB,eAAe;AACnC;AAAA,EACF;AAEA,MACE,sBAAsB;AAAA,IACpB;AAAA,IACA;AAAA,IACA;AAAA,EACN,GACI;AACA;AAAA,EACF;AAEA,wBAAsB,IAAI,eAAe,eAAe,oBAAoB;AAC5E,QAAM,YAAY,QAAQ,YAAY,aAAa;AACnD,QAAM,YAAY,QAAQ,YAAY,aAAa;AAEnD,MAAI,CAAC,aAAa,CAAC,WAAW;AAC5B;AAAA,EACF;AAEA,QAAM,CAAC,WAAW,wBAAwB,IACxC;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,EACN;AACE,QAAM,CAAC,WAAW,wBAAwB,IACxC;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,EACN;AAGE;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AAGE,aAAW,2BAA2B,0BAA0B;AAC9D;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACN;AAAA,EACE;AAGA,aAAW,2BAA2B,0BAA0B;AAC9D;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACN;AAAA,EACE;AACF;AAIA,SAAS,qCACP,SACA,8BACA,gCACA,uBACA,sBACA,aACA,eACA,aACA,eACA;AACA,QAAM,YAAY,CAAA;AAClB,QAAM,CAAC,WAAW,cAAc,IAAI;AAAA,IAClC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AACE,QAAM,CAAC,WAAW,cAAc,IAAI;AAAA,IAClC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AAEE;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AAGE,aAAW,iBAAiB,gBAAgB;AAC1C;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACN;AAAA,EACE;AAGA,aAAW,iBAAiB,gBAAgB;AAC1C;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACN;AAAA,EACE;AAIA,aAAW,iBAAiB,gBAAgB;AAC1C,eAAW,iBAAiB,gBAAgB;AAC1C;AAAA,QACE;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACR;AAAA,IACI;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,uBACP,SACA,WACA,8BACA,gCACA,uBACA,UACA;AAKA,aAAW,CAAC,cAAc,MAAM,KAAK,OAAO,QAAQ,QAAQ,GAAG;AAI7D,QAAI,OAAO,SAAS,GAAG;AACrB,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,iBAAS,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AAC1C,gBAAM,WAAW;AAAA,YACf;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA;AAAA,YACA;AAAA,YACA,OAAO,CAAC;AAAA,YACR,OAAO,CAAC;AAAA,UACpB;AAEU,cAAI,UAAU;AACZ,sBAAU,KAAK,QAAQ;AAAA,UACzB;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAMA,SAAS,wBACP,SACA,WACA,8BACA,gCACA,uBACA,kCACA,WACA,WACA;AAMA,aAAW,CAAC,cAAc,OAAO,KAAK,OAAO,QAAQ,SAAS,GAAG;AAC/D,UAAM,UAAU,UAAU,YAAY;AAEtC,QAAI,SAAS;AACX,iBAAW,UAAU,SAAS;AAC5B,mBAAW,UAAU,SAAS;AAC5B,gBAAM,WAAW;AAAA,YACf;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UACZ;AAEU,cAAI,UAAU;AACZ,sBAAU,KAAK,QAAQ;AAAA,UACzB;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAGA,SAAS,aACP,SACA,8BACA,gCACA,uBACA,kCACA,cACA,QACA,QACA;AACA,QAAM,CAAC,aAAa,OAAO,IAAI,IAAI;AACnC,QAAM,CAAC,aAAa,OAAO,IAAI,IAAI;AASnC,QAAM,uBACJ,oCACC,gBAAgB,eACf,aAAa,WAAW,KACxB,aAAa,WAAW;AAE5B,MAAI,CAAC,sBAAsB;AAEzB,UAAM,QAAQ,MAAM,KAAK;AACzB,UAAM,QAAQ,MAAM,KAAK;AAEzB,QAAI,UAAU,OAAO;AACnB,aAAO;AAAA,QACL,CAAC,cAAc,IAAI,KAAK,UAAU,KAAK,wBAAwB;AAAA,QAC/D,CAAC,KAAK;AAAA,QACN,CAAC,KAAK;AAAA,MACd;AAAA,IACI;AAEA,QAAI,CAAC,cAAc,OAAO,KAAK,GAAG;AAChC,aAAO;AAAA,QACL,CAAC,cAAc,+BAA+B;AAAA,QAC9C,CAAC,KAAK;AAAA,QACN,CAAC,KAAK;AAAA,MACd;AAAA,IACI;AAAA,EACF;AAEA,QAAM,QAAQ,SAAS,QAAQ,SAAS,SAAS,SAAS,KAAK;AAC/D,QAAM,QAAQ,SAAS,QAAQ,SAAS,SAAS,SAAS,KAAK;AAE/D,MAAI,SAAS,SAAS,gBAAgB,OAAO,KAAK,GAAG;AACnD,WAAO;AAAA,MACL;AAAA,QACE;AAAA,QACA,kCAAkC,QAAQ,KAAK,CAAC,UAAU;AAAA,UACxD;AAAA,QACV,CAAS;AAAA,MACT;AAAA,MACM,CAAC,KAAK;AAAA,MACN,CAAC,KAAK;AAAA,IACZ;AAAA,EACE;AAIA,QAAM,gBAAgB,MAAM;AAC5B,QAAM,gBAAgB,MAAM;AAE5B,MAAI,iBAAiB,eAAe;AAClC,UAAM,YAAY;AAAA,MAChB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,aAAa,KAAK;AAAA,MAClB;AAAA,MACA,aAAa,KAAK;AAAA,MAClB;AAAA,IACN;AACI,WAAO,kBAAkB,WAAW,cAAc,OAAO,KAAK;AAAA,EAChE;AACF;AAEA,SAAS,cAAc,OAAO,OAAO;AACnC,QAAM,QAAQ,MAAM;AACpB,QAAM,QAAQ,MAAM;AAEpB,MAAI,UAAU,UAAa,MAAM,WAAW,GAAG;AAC7C,WAAO,UAAU,UAAa,MAAM,WAAW;AAAA,EACjD;AAEA,MAAI,UAAU,UAAa,MAAM,WAAW,GAAG;AAC7C,WAAO;AAAA,EACT;AAGA,MAAI,MAAM,WAAW,MAAM,QAAQ;AAEjC,WAAO;AAAA,EAET;AAEA,QAAM,UAAU,IAAI,IAAI,MAAM,IAAI,CAAC,EAAE,MAAM,MAAK,MAAO,CAAC,KAAK,OAAO,KAAK,CAAC,CAAC;AAC3E,SAAO,MAAM,MAAM,CAAC,SAAS;AAC3B,UAAM,SAAS,KAAK;AACpB,UAAM,SAAS,QAAQ,IAAI,KAAK,KAAK,KAAK;AAE1C,QAAI,WAAW,QAAW;AACxB,aAAO;AAAA,IACT;AAEA,WAAO,eAAe,MAAM,MAAM,eAAe,MAAM;AAAA,EACzD,CAAC;AACH;AAEA,SAAS,eAAe,OAAO;AAC7B,SAAO,MAAM,cAAc,KAAK,CAAC;AACnC;AAIA,SAAS,gBAAgB,OAAO,OAAO;AACrC,MAAI,WAAW,KAAK,GAAG;AACrB,WAAO,WAAW,KAAK,IACnB,gBAAgB,MAAM,QAAQ,MAAM,MAAM,IAC1C;AAAA,EACN;AAEA,MAAI,WAAW,KAAK,GAAG;AACrB,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,KAAK,GAAG;AACxB,WAAO,cAAc,KAAK,IACtB,gBAAgB,MAAM,QAAQ,MAAM,MAAM,IAC1C;AAAA,EACN;AAEA,MAAI,cAAc,KAAK,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,KAAK,KAAK,WAAW,KAAK,GAAG;AAC1C,WAAO,UAAU;AAAA,EACnB;AAEA,SAAO;AACT;AAIA,SAAS,0BACP,SACA,8BACA,YACA,cACA;AACA,QAAM,SAAS,6BAA6B,IAAI,YAAY;AAE5D,MAAI,QAAQ;AACV,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,uBAAO,OAAO,IAAI;AACtC,QAAM,gBAAgB,uBAAO,OAAO,IAAI;AAExC;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AAEE,QAAM,SAAS,CAAC,aAAa,OAAO,KAAK,aAAa,CAAC;AACvD,+BAA6B,IAAI,cAAc,MAAM;AACrD,SAAO;AACT;AAGA,SAAS,oCACP,SACA,8BACA,UACA;AAEA,QAAM,SAAS,6BAA6B,IAAI,SAAS,YAAY;AAErE,MAAI,QAAQ;AACV,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,YAAY,QAAQ,UAAS,GAAI,SAAS,aAAa;AAC5E,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS;AAAA,EACb;AACA;AAEA,SAAS,+BACP,SACA,YACA,cACA,aACA,eACA;AACA,aAAW,aAAa,aAAa,YAAY;AAC/C,YAAQ,UAAU,MAAI;AAAA,MACpB,KAAK,KAAK,OAAO;AACf,cAAM,YAAY,UAAU,KAAK;AACjC,YAAI;AAEJ,YAAI,aAAa,UAAU,KAAK,gBAAgB,UAAU,GAAG;AAC3D,qBAAW,WAAW,UAAS,EAAG,SAAS;AAAA,QAC7C;AAEA,cAAM,eAAe,UAAU,QAC3B,UAAU,MAAM,QAChB;AAEJ,YAAI,CAAC,YAAY,YAAY,GAAG;AAC9B,sBAAY,YAAY,IAAI,CAAA;AAAA,QAC9B;AAEA,oBAAY,YAAY,EAAE,KAAK,CAAC,YAAY,WAAW,QAAQ,CAAC;AAChE;AAAA,MACF;AAAA,MAEA,KAAK,KAAK;AACR,sBAAc,UAAU,KAAK,KAAK,IAAI;AACtC;AAAA,MAEF,KAAK,KAAK,iBAAiB;AACzB,cAAM,gBAAgB,UAAU;AAChC,cAAM,qBAAqB,gBACvB,YAAY,QAAQ,UAAS,GAAI,aAAa,IAC9C;AAEJ;AAAA,UACE;AAAA,UACA;AAAA,UACA,UAAU;AAAA,UACV;AAAA,UACA;AAAA,QACV;AAEQ;AAAA,MACF;AAAA,IACN;AAAA,EACE;AACF;AAGA,SAAS,kBAAkB,WAAW,cAAc,OAAO,OAAO;AAChE,MAAI,UAAU,SAAS,GAAG;AACxB,WAAO;AAAA,MACL,CAAC,cAAc,UAAU,IAAI,CAAC,CAAC,MAAM,MAAM,MAAM,CAAC;AAAA,MAClD,CAAC,OAAO,GAAG,UAAU,IAAI,CAAC,CAAA,EAAG,OAAO,MAAM,OAAO,EAAE,MAAM;AAAA,MACzD,CAAC,OAAO,GAAG,UAAU,IAAI,CAAC,CAAA,EAAA,EAAK,OAAO,MAAM,OAAO,EAAE,MAAM;AAAA,IACjE;AAAA,EACE;AACF;AASA,MAAM,eAAe;AAAA,EACnB,cAAc;AACZ,SAAK,QAAQ,oBAAI,IAAG;AAAA,EACtB;AAAA,EAEA,IAAI,GAAG,GAAG,eAAe;AACvB,QAAI;AAEJ,UAAM,UACH,kBAAkB,KAAK,MAAM,IAAI,CAAC,OAAO,QAC1C,oBAAoB,SAChB,SACA,gBAAgB,IAAI,CAAC;AAE3B,QAAI,WAAW,QAAW;AACxB,aAAO;AAAA,IACT;AAEA,WAAO,gBAAgB,OAAO,kBAAkB;AAAA,EAClD;AAAA,EAEA,IAAI,GAAG,GAAG,eAAe;AACvB,UAAM,MAAM,KAAK,MAAM,IAAI,CAAC;AAE5B,QAAI,QAAQ,QAAW;AACrB,WAAK,MAAM,IAAI,GAAG,oBAAI,IAAI,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC;AAAA,IACjD,OAAO;AACL,UAAI,IAAI,GAAG,aAAa;AAAA,IAC1B;AAAA,EACF;AACF;AAMA,MAAM,QAAQ;AAAA,EACZ,cAAc;AACZ,SAAK,kBAAkB,IAAI,eAAc;AAAA,EAC3C;AAAA,EAEA,IAAI,GAAG,GAAG,eAAe;AACvB,WAAO,IAAI,IACP,KAAK,gBAAgB,IAAI,GAAG,GAAG,aAAa,IAC5C,KAAK,gBAAgB,IAAI,GAAG,GAAG,aAAa;AAAA,EAClD;AAAA,EAEA,IAAI,GAAG,GAAG,eAAe;AACvB,QAAI,IAAI,GAAG;AACT,WAAK,gBAAgB,IAAI,GAAG,GAAG,aAAa;AAAA,IAC9C,OAAO;AACL,WAAK,gBAAgB,IAAI,GAAG,GAAG,aAAa;AAAA,IAC9C;AAAA,EACF;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/validation/rules/PossibleFragmentSpreadsRule.js

@@ -0,0 +1,55 @@
+import { inspect } from "../../jsutils/inspect.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { isCompositeType } from "../../type/definition.js";
+import { doTypesOverlap } from "../../utilities/typeComparators.js";
+import { typeFromAST } from "../../utilities/typeFromAST.js";
+function PossibleFragmentSpreadsRule(context) {
+  return {
+    InlineFragment(node) {
+      const fragType = context.getType();
+      const parentType = context.getParentType();
+      if (isCompositeType(fragType) && isCompositeType(parentType) && !doTypesOverlap(context.getSchema(), fragType, parentType)) {
+        const parentTypeStr = inspect(parentType);
+        const fragTypeStr = inspect(fragType);
+        context.reportError(
+          new GraphQLError(
+            `Fragment cannot be spread here as objects of type "${parentTypeStr}" can never be of type "${fragTypeStr}".`,
+            {
+              nodes: node
+            }
+          )
+        );
+      }
+    },
+    FragmentSpread(node) {
+      const fragName = node.name.value;
+      const fragType = getFragmentType(context, fragName);
+      const parentType = context.getParentType();
+      if (fragType && parentType && !doTypesOverlap(context.getSchema(), fragType, parentType)) {
+        const parentTypeStr = inspect(parentType);
+        const fragTypeStr = inspect(fragType);
+        context.reportError(
+          new GraphQLError(
+            `Fragment "${fragName}" cannot be spread here as objects of type "${parentTypeStr}" can never be of type "${fragTypeStr}".`,
+            {
+              nodes: node
+            }
+          )
+        );
+      }
+    }
+  };
+}
+function getFragmentType(context, name) {
+  const frag = context.getFragment(name);
+  if (frag) {
+    const type = typeFromAST(context.getSchema(), frag.typeCondition);
+    if (isCompositeType(type)) {
+      return type;
+    }
+  }
+}
+export {
+  PossibleFragmentSpreadsRule
+};
+//# sourceMappingURL=PossibleFragmentSpreadsRule.js.map

package/dist/node_modules/graphql/validation/rules/PossibleFragmentSpreadsRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PossibleFragmentSpreadsRule.js","sources":["../../../../../node_modules/graphql/validation/rules/PossibleFragmentSpreadsRule.mjs"],"sourcesContent":["import { inspect } from '../../jsutils/inspect.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { isCompositeType } from '../../type/definition.mjs';\nimport { doTypesOverlap } from '../../utilities/typeComparators.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Possible fragment spread\n *\n * A fragment spread is only valid if the type condition could ever possibly\n * be true: if there is a non-empty intersection of the possible parent types,\n * and possible types which pass the type condition.\n */\nexport function PossibleFragmentSpreadsRule(context) {\n  return {\n    InlineFragment(node) {\n      const fragType = context.getType();\n      const parentType = context.getParentType();\n\n      if (\n        isCompositeType(fragType) &&\n        isCompositeType(parentType) &&\n        !doTypesOverlap(context.getSchema(), fragType, parentType)\n      ) {\n        const parentTypeStr = inspect(parentType);\n        const fragTypeStr = inspect(fragType);\n        context.reportError(\n          new GraphQLError(\n            `Fragment cannot be spread here as objects of type \"${parentTypeStr}\" can never be of type \"${fragTypeStr}\".`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n\n    FragmentSpread(node) {\n      const fragName = node.name.value;\n      const fragType = getFragmentType(context, fragName);\n      const parentType = context.getParentType();\n\n      if (\n        fragType &&\n        parentType &&\n        !doTypesOverlap(context.getSchema(), fragType, parentType)\n      ) {\n        const parentTypeStr = inspect(parentType);\n        const fragTypeStr = inspect(fragType);\n        context.reportError(\n          new GraphQLError(\n            `Fragment \"${fragName}\" cannot be spread here as objects of type \"${parentTypeStr}\" can never be of type \"${fragTypeStr}\".`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n\nfunction getFragmentType(context, name) {\n  const frag = context.getFragment(name);\n\n  if (frag) {\n    const type = typeFromAST(context.getSchema(), frag.typeCondition);\n\n    if (isCompositeType(type)) {\n      return type;\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;AAaO,SAAS,4BAA4B,SAAS;AACnD,SAAO;AAAA,IACL,eAAe,MAAM;AACnB,YAAM,WAAW,QAAQ,QAAO;AAChC,YAAM,aAAa,QAAQ,cAAa;AAExC,UACE,gBAAgB,QAAQ,KACxB,gBAAgB,UAAU,KAC1B,CAAC,eAAe,QAAQ,UAAS,GAAI,UAAU,UAAU,GACzD;AACA,cAAM,gBAAgB,QAAQ,UAAU;AACxC,cAAM,cAAc,QAAQ,QAAQ;AACpC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,sDAAsD,aAAa,2BAA2B,WAAW;AAAA,YACzG;AAAA,cACE,OAAO;AAAA,YACrB;AAAA,UACA;AAAA,QACA;AAAA,MACM;AAAA,IACF;AAAA,IAEA,eAAe,MAAM;AACnB,YAAM,WAAW,KAAK,KAAK;AAC3B,YAAM,WAAW,gBAAgB,SAAS,QAAQ;AAClD,YAAM,aAAa,QAAQ,cAAa;AAExC,UACE,YACA,cACA,CAAC,eAAe,QAAQ,UAAS,GAAI,UAAU,UAAU,GACzD;AACA,cAAM,gBAAgB,QAAQ,UAAU;AACxC,cAAM,cAAc,QAAQ,QAAQ;AACpC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,aAAa,QAAQ,+CAA+C,aAAa,2BAA2B,WAAW;AAAA,YACvH;AAAA,cACE,OAAO;AAAA,YACrB;AAAA,UACA;AAAA,QACA;AAAA,MACM;AAAA,IACF;AAAA,EACJ;AACA;AAEA,SAAS,gBAAgB,SAAS,MAAM;AACtC,QAAM,OAAO,QAAQ,YAAY,IAAI;AAErC,MAAI,MAAM;AACR,UAAM,OAAO,YAAY,QAAQ,UAAS,GAAI,KAAK,aAAa;AAEhE,QAAI,gBAAgB,IAAI,GAAG;AACzB,aAAO;AAAA,IACT;AAAA,EACF;AACF;","x_google_ignoreList":[0]}