mirror of
https://github.com/JamesIves/github-pages-deploy-action.git
synced 2023-12-15 20:03:39 +08:00
573 lines
24 KiB
JavaScript
573 lines
24 KiB
JavaScript
import find from "../../polyfills/find.mjs";
|
|
import objectEntries from "../../polyfills/objectEntries.mjs";
|
|
import inspect from "../../jsutils/inspect.mjs";
|
|
import { GraphQLError } from "../../error/GraphQLError.mjs";
|
|
import { Kind } from "../../language/kinds.mjs";
|
|
import { print } from "../../language/printer.mjs";
|
|
import { getNamedType, isNonNullType, isLeafType, isObjectType, isListType, isInterfaceType } from "../../type/definition.mjs";
|
|
import { typeFromAST } from "../../utilities/typeFromAST.mjs";
|
|
|
|
function reasonMessage(reason) {
|
|
if (Array.isArray(reason)) {
|
|
return reason.map(function (_ref) {
|
|
var responseName = _ref[0],
|
|
subReason = _ref[1];
|
|
return "subfields \"".concat(responseName, "\" conflict because ") + reasonMessage(subReason);
|
|
}).join(' and ');
|
|
}
|
|
|
|
return reason;
|
|
}
|
|
/**
|
|
* Overlapping fields can be merged
|
|
*
|
|
* A selection set is only valid if all fields (including spreading any
|
|
* fragments) either correspond to distinct response names or can be merged
|
|
* without ambiguity.
|
|
*/
|
|
|
|
|
|
export function OverlappingFieldsCanBeMergedRule(context) {
|
|
// A memoization for when two fragments are compared "between" each other for
|
|
// conflicts. Two fragments may be compared many times, so memoizing this can
|
|
// dramatically improve the performance of this validator.
|
|
var comparedFragmentPairs = new PairSet(); // A cache for the "field map" and list of fragment names found in any given
|
|
// selection set. Selection sets may be asked for this information multiple
|
|
// times, so this improves the performance of this validator.
|
|
|
|
var cachedFieldsAndFragmentNames = new Map();
|
|
return {
|
|
SelectionSet: function SelectionSet(selectionSet) {
|
|
var conflicts = findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, context.getParentType(), selectionSet);
|
|
|
|
for (var _i2 = 0; _i2 < conflicts.length; _i2++) {
|
|
var _ref3 = conflicts[_i2];
|
|
var _ref2$ = _ref3[0];
|
|
var responseName = _ref2$[0];
|
|
var reason = _ref2$[1];
|
|
var fields1 = _ref3[1];
|
|
var fields2 = _ref3[2];
|
|
var reasonMsg = reasonMessage(reason);
|
|
context.reportError(new GraphQLError("Fields \"".concat(responseName, "\" conflict because ").concat(reasonMsg, ". Use different aliases on the fields to fetch both if this was intentional."), fields1.concat(fields2)));
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Algorithm:
|
|
*
|
|
* Conflicts occur when two fields exist in a query which will produce the same
|
|
* response name, but represent differing values, thus creating a conflict.
|
|
* The algorithm below finds all conflicts via making a series of comparisons
|
|
* between fields. In order to compare as few fields as possible, this makes
|
|
* a series of comparisons "within" sets of fields and "between" sets of fields.
|
|
*
|
|
* Given any selection set, a collection produces both a set of fields by
|
|
* also including all inline fragments, as well as a list of fragments
|
|
* referenced by fragment spreads.
|
|
*
|
|
* A) Each selection set represented in the document first compares "within" its
|
|
* collected set of fields, finding any conflicts between every pair of
|
|
* overlapping fields.
|
|
* Note: This is the *only time* that a the fields "within" a set are compared
|
|
* to each other. After this only fields "between" sets are compared.
|
|
*
|
|
* B) Also, if any fragment is referenced in a selection set, then a
|
|
* comparison is made "between" the original set of fields and the
|
|
* referenced fragment.
|
|
*
|
|
* C) Also, if multiple fragments are referenced, then comparisons
|
|
* are made "between" each referenced fragment.
|
|
*
|
|
* D) When comparing "between" a set of fields and a referenced fragment, first
|
|
* a comparison is made between each field in the original set of fields and
|
|
* each field in the the referenced set of fields.
|
|
*
|
|
* E) Also, if any fragment is referenced in the referenced selection set,
|
|
* then a comparison is made "between" the original set of fields and the
|
|
* referenced fragment (recursively referring to step D).
|
|
*
|
|
* F) When comparing "between" two fragments, first a comparison is made between
|
|
* each field in the first referenced set of fields and each field in the the
|
|
* second referenced set of fields.
|
|
*
|
|
* G) Also, any fragments referenced by the first must be compared to the
|
|
* second, and any fragments referenced by the second must be compared to the
|
|
* first (recursively referring to step F).
|
|
*
|
|
* H) When comparing two fields, if both have selection sets, then a comparison
|
|
* is made "between" both selection sets, first comparing the set of fields in
|
|
* the first selection set with the set of fields in the second.
|
|
*
|
|
* I) Also, if any fragment is referenced in either selection set, then a
|
|
* comparison is made "between" the other set of fields and the
|
|
* referenced fragment.
|
|
*
|
|
* J) Also, if two fragments are referenced in both selection sets, then a
|
|
* comparison is made "between" the two fragments.
|
|
*
|
|
*/
|
|
// Find all conflicts found "within" a selection set, including those found
|
|
// via spreading in fragments. Called when visiting each SelectionSet in the
|
|
// GraphQL Document.
|
|
function findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentType, selectionSet) {
|
|
var conflicts = [];
|
|
|
|
var _getFieldsAndFragment = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet),
|
|
fieldMap = _getFieldsAndFragment[0],
|
|
fragmentNames = _getFieldsAndFragment[1]; // (A) Find find all conflicts "within" the fields of this selection set.
|
|
// Note: this is the *only place* `collectConflictsWithin` is called.
|
|
|
|
|
|
collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, fieldMap);
|
|
|
|
if (fragmentNames.length !== 0) {
|
|
// (B) Then collect conflicts between these fields and those represented by
|
|
// each spread fragment name found.
|
|
for (var i = 0; i < fragmentNames.length; i++) {
|
|
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, false, fieldMap, fragmentNames[i]); // (C) Then compare this fragment with all other fragments found in this
|
|
// selection set to collect conflicts between fragments spread together.
|
|
// This compares each item in the list of fragment names to every other
|
|
// item in that same list (except for itself).
|
|
|
|
for (var j = i + 1; j < fragmentNames.length; j++) {
|
|
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, false, fragmentNames[i], fragmentNames[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return conflicts;
|
|
} // Collect all conflicts found between a set of fields and a fragment reference
|
|
// including via spreading in any nested fragments.
|
|
|
|
|
|
function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentName) {
|
|
var fragment = context.getFragment(fragmentName);
|
|
|
|
if (!fragment) {
|
|
return;
|
|
}
|
|
|
|
var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment),
|
|
fieldMap2 = _getReferencedFieldsA[0],
|
|
fragmentNames2 = _getReferencedFieldsA[1]; // Do not compare a fragment's fieldMap to itself.
|
|
|
|
|
|
if (fieldMap === fieldMap2) {
|
|
return;
|
|
} // (D) First collect any conflicts between the provided collection of fields
|
|
// and the collection of fields represented by the given fragment.
|
|
|
|
|
|
collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fieldMap2); // (E) Then collect any conflicts between the provided collection of fields
|
|
// and any fragment names found in the given fragment.
|
|
|
|
for (var i = 0; i < fragmentNames2.length; i++) {
|
|
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap, fragmentNames2[i]);
|
|
}
|
|
} // Collect all conflicts found between two fragments, including via spreading in
|
|
// any nested fragments.
|
|
|
|
|
|
function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentName1, fragmentName2) {
|
|
// No need to compare a fragment to itself.
|
|
if (fragmentName1 === fragmentName2) {
|
|
return;
|
|
} // Memoize so two fragments are not compared for conflicts more than once.
|
|
|
|
|
|
if (comparedFragmentPairs.has(fragmentName1, fragmentName2, areMutuallyExclusive)) {
|
|
return;
|
|
}
|
|
|
|
comparedFragmentPairs.add(fragmentName1, fragmentName2, areMutuallyExclusive);
|
|
var fragment1 = context.getFragment(fragmentName1);
|
|
var fragment2 = context.getFragment(fragmentName2);
|
|
|
|
if (!fragment1 || !fragment2) {
|
|
return;
|
|
}
|
|
|
|
var _getReferencedFieldsA2 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment1),
|
|
fieldMap1 = _getReferencedFieldsA2[0],
|
|
fragmentNames1 = _getReferencedFieldsA2[1];
|
|
|
|
var _getReferencedFieldsA3 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment2),
|
|
fieldMap2 = _getReferencedFieldsA3[0],
|
|
fragmentNames2 = _getReferencedFieldsA3[1]; // (F) First, collect all conflicts between these two collections of fields
|
|
// (not including any nested fragments).
|
|
|
|
|
|
collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fieldMap2); // (G) Then collect conflicts between the first fragment and any nested
|
|
// fragments spread in the second fragment.
|
|
|
|
for (var j = 0; j < fragmentNames2.length; j++) {
|
|
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentName1, fragmentNames2[j]);
|
|
} // (G) Then collect conflicts between the second fragment and any nested
|
|
// fragments spread in the first fragment.
|
|
|
|
|
|
for (var i = 0; i < fragmentNames1.length; i++) {
|
|
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentNames1[i], fragmentName2);
|
|
}
|
|
} // Find all conflicts found between two selection sets, including those found
|
|
// via spreading in fragments. Called when determining if conflicts exist
|
|
// between the sub-fields of two overlapping fields.
|
|
|
|
|
|
function findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, parentType1, selectionSet1, parentType2, selectionSet2) {
|
|
var conflicts = [];
|
|
|
|
var _getFieldsAndFragment2 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType1, selectionSet1),
|
|
fieldMap1 = _getFieldsAndFragment2[0],
|
|
fragmentNames1 = _getFieldsAndFragment2[1];
|
|
|
|
var _getFieldsAndFragment3 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType2, selectionSet2),
|
|
fieldMap2 = _getFieldsAndFragment3[0],
|
|
fragmentNames2 = _getFieldsAndFragment3[1]; // (H) First, collect all conflicts between these two collections of field.
|
|
|
|
|
|
collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fieldMap2); // (I) Then collect conflicts between the first collection of fields and
|
|
// those referenced by each fragment name associated with the second.
|
|
|
|
if (fragmentNames2.length !== 0) {
|
|
for (var j = 0; j < fragmentNames2.length; j++) {
|
|
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap1, fragmentNames2[j]);
|
|
}
|
|
} // (I) Then collect conflicts between the second collection of fields and
|
|
// those referenced by each fragment name associated with the first.
|
|
|
|
|
|
if (fragmentNames1.length !== 0) {
|
|
for (var i = 0; i < fragmentNames1.length; i++) {
|
|
collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fieldMap2, fragmentNames1[i]);
|
|
}
|
|
} // (J) Also collect conflicts between any fragment names by the first and
|
|
// fragment names by the second. This compares each item in the first set of
|
|
// names to each item in the second set of names.
|
|
|
|
|
|
for (var _i3 = 0; _i3 < fragmentNames1.length; _i3++) {
|
|
for (var _j = 0; _j < fragmentNames2.length; _j++) {
|
|
collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, fragmentNames1[_i3], fragmentNames2[_j]);
|
|
}
|
|
}
|
|
|
|
return conflicts;
|
|
} // Collect all Conflicts "within" one collection of fields.
|
|
|
|
|
|
function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, fieldMap) {
|
|
// A field map is a keyed collection, where each key represents a response
|
|
// name and the value at that key is a list of all fields which provide that
|
|
// response name. For every response name, if there are multiple fields, they
|
|
// must be compared to find a potential conflict.
|
|
for (var _i5 = 0, _objectEntries2 = objectEntries(fieldMap); _i5 < _objectEntries2.length; _i5++) {
|
|
var _ref5 = _objectEntries2[_i5];
|
|
var responseName = _ref5[0];
|
|
var fields = _ref5[1];
|
|
|
|
// This compares every field in the list to every other field in this list
|
|
// (except to itself). If the list only has one item, nothing needs to
|
|
// be compared.
|
|
if (fields.length > 1) {
|
|
for (var i = 0; i < fields.length; i++) {
|
|
for (var j = i + 1; j < fields.length; j++) {
|
|
var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, false, // within one collection is never mutually exclusive
|
|
responseName, fields[i], fields[j]);
|
|
|
|
if (conflict) {
|
|
conflicts.push(conflict);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} // Collect all Conflicts between two collections of fields. This is similar to,
|
|
// but different from the `collectConflictsWithin` function above. This check
|
|
// assumes that `collectConflictsWithin` has already been called on each
|
|
// provided collection of fields. This is true because this validator traverses
|
|
// each individual selection set.
|
|
|
|
|
|
function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, fieldMap1, fieldMap2) {
|
|
// A field map is a keyed collection, where each key represents a response
|
|
// name and the value at that key is a list of all fields which provide that
|
|
// response name. For any response name which appears in both provided field
|
|
// maps, each field from the first field map must be compared to every field
|
|
// in the second field map to find potential conflicts.
|
|
for (var _i7 = 0, _Object$keys2 = Object.keys(fieldMap1); _i7 < _Object$keys2.length; _i7++) {
|
|
var responseName = _Object$keys2[_i7];
|
|
var fields2 = fieldMap2[responseName];
|
|
|
|
if (fields2) {
|
|
var fields1 = fieldMap1[responseName];
|
|
|
|
for (var i = 0; i < fields1.length; i++) {
|
|
for (var j = 0; j < fields2.length; j++) {
|
|
var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, responseName, fields1[i], fields2[j]);
|
|
|
|
if (conflict) {
|
|
conflicts.push(conflict);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} // Determines if there is a conflict between two particular fields, including
|
|
// comparing their sub-fields.
|
|
|
|
|
|
function findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, parentFieldsAreMutuallyExclusive, responseName, field1, field2) {
|
|
var parentType1 = field1[0],
|
|
node1 = field1[1],
|
|
def1 = field1[2];
|
|
var parentType2 = field2[0],
|
|
node2 = field2[1],
|
|
def2 = field2[2]; // If it is known that two fields could not possibly apply at the same
|
|
// time, due to the parent types, then it is safe to permit them to diverge
|
|
// in aliased field or arguments used as they will not present any ambiguity
|
|
// by differing.
|
|
// It is known that two parent types could never overlap if they are
|
|
// different Object types. Interface or Union types might overlap - if not
|
|
// in the current state of the schema, then perhaps in some future version,
|
|
// thus may not safely diverge.
|
|
|
|
var areMutuallyExclusive = parentFieldsAreMutuallyExclusive || parentType1 !== parentType2 && isObjectType(parentType1) && isObjectType(parentType2);
|
|
|
|
if (!areMutuallyExclusive) {
|
|
var _node1$arguments, _node2$arguments;
|
|
|
|
// Two aliases must refer to the same field.
|
|
var name1 = node1.name.value;
|
|
var name2 = node2.name.value;
|
|
|
|
if (name1 !== name2) {
|
|
return [[responseName, "\"".concat(name1, "\" and \"").concat(name2, "\" are different fields")], [node1], [node2]];
|
|
}
|
|
/* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
|
|
|
|
|
|
var args1 = (_node1$arguments = node1.arguments) !== null && _node1$arguments !== void 0 ? _node1$arguments : [];
|
|
/* istanbul ignore next (See https://github.com/graphql/graphql-js/issues/2203) */
|
|
|
|
var args2 = (_node2$arguments = node2.arguments) !== null && _node2$arguments !== void 0 ? _node2$arguments : []; // Two field calls must have the same arguments.
|
|
|
|
if (!sameArguments(args1, args2)) {
|
|
return [[responseName, 'they have differing arguments'], [node1], [node2]];
|
|
}
|
|
} // The return type for each field.
|
|
|
|
|
|
var type1 = def1 === null || def1 === void 0 ? void 0 : def1.type;
|
|
var type2 = def2 === null || def2 === void 0 ? void 0 : def2.type;
|
|
|
|
if (type1 && type2 && doTypesConflict(type1, type2)) {
|
|
return [[responseName, "they return conflicting types \"".concat(inspect(type1), "\" and \"").concat(inspect(type2), "\"")], [node1], [node2]];
|
|
} // Collect and compare sub-fields. Use the same "visited fragment names" list
|
|
// for both collections so fields in a fragment reference are never
|
|
// compared to themselves.
|
|
|
|
|
|
var selectionSet1 = node1.selectionSet;
|
|
var selectionSet2 = node2.selectionSet;
|
|
|
|
if (selectionSet1 && selectionSet2) {
|
|
var conflicts = findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragmentPairs, areMutuallyExclusive, getNamedType(type1), selectionSet1, getNamedType(type2), selectionSet2);
|
|
return subfieldConflicts(conflicts, responseName, node1, node2);
|
|
}
|
|
}
|
|
|
|
function sameArguments(arguments1, arguments2) {
|
|
if (arguments1.length !== arguments2.length) {
|
|
return false;
|
|
}
|
|
|
|
return arguments1.every(function (argument1) {
|
|
var argument2 = find(arguments2, function (argument) {
|
|
return argument.name.value === argument1.name.value;
|
|
});
|
|
|
|
if (!argument2) {
|
|
return false;
|
|
}
|
|
|
|
return sameValue(argument1.value, argument2.value);
|
|
});
|
|
}
|
|
|
|
function sameValue(value1, value2) {
|
|
return print(value1) === print(value2);
|
|
} // Two types conflict if both types could not apply to a value simultaneously.
|
|
// Composite types are ignored as their individual field types will be compared
|
|
// later recursively. However List and Non-Null types must match.
|
|
|
|
|
|
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;
|
|
} // Given a selection set, return the collection of fields (a mapping of response
|
|
// name to field nodes and definitions) as well as a list of fragment names
|
|
// referenced via fragment spreads.
|
|
|
|
|
|
function getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet) {
|
|
var cached = cachedFieldsAndFragmentNames.get(selectionSet);
|
|
|
|
if (!cached) {
|
|
var nodeAndDefs = Object.create(null);
|
|
var fragmentNames = Object.create(null);
|
|
|
|
_collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames);
|
|
|
|
cached = [nodeAndDefs, Object.keys(fragmentNames)];
|
|
cachedFieldsAndFragmentNames.set(selectionSet, cached);
|
|
}
|
|
|
|
return cached;
|
|
} // Given a reference to a fragment, return the represented collection of fields
|
|
// as well as a list of nested fragment names referenced via fragment spreads.
|
|
|
|
|
|
function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment) {
|
|
// Short-circuit building a type from the node if possible.
|
|
var cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);
|
|
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
|
|
var fragmentType = typeFromAST(context.getSchema(), fragment.typeCondition);
|
|
return getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragmentType, fragment.selectionSet);
|
|
}
|
|
|
|
function _collectFieldsAndFragmentNames(context, parentType, selectionSet, nodeAndDefs, fragmentNames) {
|
|
for (var _i9 = 0, _selectionSet$selecti2 = selectionSet.selections; _i9 < _selectionSet$selecti2.length; _i9++) {
|
|
var selection = _selectionSet$selecti2[_i9];
|
|
|
|
switch (selection.kind) {
|
|
case Kind.FIELD:
|
|
{
|
|
var fieldName = selection.name.value;
|
|
var fieldDef = void 0;
|
|
|
|
if (isObjectType(parentType) || isInterfaceType(parentType)) {
|
|
fieldDef = parentType.getFields()[fieldName];
|
|
}
|
|
|
|
var 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:
|
|
{
|
|
var typeCondition = selection.typeCondition;
|
|
var inlineFragmentType = typeCondition ? typeFromAST(context.getSchema(), typeCondition) : parentType;
|
|
|
|
_collectFieldsAndFragmentNames(context, inlineFragmentType, selection.selectionSet, nodeAndDefs, fragmentNames);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} // Given a series of Conflicts which occurred between two sub-fields, generate
|
|
// a single Conflict.
|
|
|
|
|
|
function subfieldConflicts(conflicts, responseName, node1, node2) {
|
|
if (conflicts.length > 0) {
|
|
return [[responseName, conflicts.map(function (_ref6) {
|
|
var reason = _ref6[0];
|
|
return reason;
|
|
})], conflicts.reduce(function (allFields, _ref7) {
|
|
var fields1 = _ref7[1];
|
|
return allFields.concat(fields1);
|
|
}, [node1]), conflicts.reduce(function (allFields, _ref8) {
|
|
var fields2 = _ref8[2];
|
|
return allFields.concat(fields2);
|
|
}, [node2])];
|
|
}
|
|
}
|
|
/**
|
|
* A way to keep track of pairs of things when the ordering of the pair does
|
|
* not matter. We do this by maintaining a sort of double adjacency sets.
|
|
*/
|
|
|
|
|
|
var PairSet =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function PairSet() {
|
|
this._data = Object.create(null);
|
|
}
|
|
|
|
var _proto = PairSet.prototype;
|
|
|
|
_proto.has = function has(a, b, areMutuallyExclusive) {
|
|
var first = this._data[a];
|
|
var result = first && first[b];
|
|
|
|
if (result === undefined) {
|
|
return false;
|
|
} // areMutuallyExclusive being false is a superset of being true,
|
|
// hence if we want to know if this PairSet "has" these two with no
|
|
// exclusivity, we have to ensure it was added as such.
|
|
|
|
|
|
if (areMutuallyExclusive === false) {
|
|
return result === false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
_proto.add = function add(a, b, areMutuallyExclusive) {
|
|
_pairSetAdd(this._data, a, b, areMutuallyExclusive);
|
|
|
|
_pairSetAdd(this._data, b, a, areMutuallyExclusive);
|
|
};
|
|
|
|
return PairSet;
|
|
}();
|
|
|
|
function _pairSetAdd(data, a, b, areMutuallyExclusive) {
|
|
var map = data[a];
|
|
|
|
if (!map) {
|
|
map = Object.create(null);
|
|
data[a] = map;
|
|
}
|
|
|
|
map[b] = areMutuallyExclusive;
|
|
}
|