Extract type comparators into the public API

This adds the utilities isEqualType, isTypeSubTypeOf, and doTypesOverlap to the public API.

Author: leebyron

src/index.js

@@ -154,4 +154,9 @@ export {
 
   // Concatenates multiple AST together.
   concatAST,
+
+  // Comparators for types
+  isEqualType,
+  isTypeSubTypeOf,
+  doTypesOverlap,
 } from './utilities';

src/utilities/index.js

@@ -47,3 +47,10 @@ export { isValidLiteralValue } from './isValidLiteralValue';
 
 // Concatenates multiple AST together.
 export { concatAST } from './concatAST';
+
+// Comparators for types
+export {
+  isEqualType,
+  isTypeSubTypeOf,
+  doTypesOverlap
+} from './typeComparators';

src/utilities/typeComparators.js

@@ -11,10 +11,16 @@
 import {
   isAbstractType,
   GraphQLObjectType,
+  GraphQLInterfaceType,
+  GraphQLUnionType,
   GraphQLList,
   GraphQLNonNull,
 } from '../type/definition';
-import type { GraphQLType, GraphQLAbstractType } from '../type/definition';
+import type {
+  GraphQLType,
+  GraphQLCompositeType,
+  GraphQLAbstractType
+} from '../type/definition';
 
 
 /**
@@ -86,3 +92,46 @@ export function isTypeSubTypeOf(
   // Otherwise, the child type is not a valid subtype of the parent type.
   return false;
 }
+
+/**
+ * Provided two composite types, determine if they "overlap". Two composite
+ * types overlap when the Sets of possible concrete types for each intersect.
+ *
+ * This is often used to determine if a fragment of a given type could possibly
+ * be visited in a context of another type.
+ *
+ * This function is commutative.
+ */
+export function doTypesOverlap(
+  typeA: GraphQLCompositeType,
+  typeB: GraphQLCompositeType
+): boolean {
+  // So flow is aware this is constant
+  const _typeB = typeB;
+
+  // Equivalent types overlap
+  if (typeA === _typeB) {
+    return true;
+  }
+
+  if (typeA instanceof GraphQLInterfaceType ||
+      typeA instanceof GraphQLUnionType) {
+    if (_typeB instanceof GraphQLInterfaceType ||
+        _typeB instanceof GraphQLUnionType) {
+      // If both types are abstract, then determine if there is any intersection
+      // between possible concrete types of each.
+      return typeA.getPossibleTypes().some(type => _typeB.isPossibleType(type));
+    }
+    // Determine if the latter type is a possible concrete type of the former.
+    return typeA.isPossibleType(_typeB);
+  }
+
+  if (_typeB instanceof GraphQLInterfaceType ||
+      _typeB instanceof GraphQLUnionType) {
+    // Determine if the former type is a possible concrete type of the latter.
+    return _typeB.isPossibleType(typeA);
+  }
+
+  // Otherwise the types do not overlap.
+  return false;
+}

src/validation/rules/PossibleFragmentSpreads.js

@@ -10,12 +10,7 @@
 
 import type { ValidationContext } from '../index';
 import { GraphQLError } from '../../error';
-import keyMap from '../../jsutils/keyMap';
-import {
-  GraphQLObjectType,
-  GraphQLInterfaceType,
-  GraphQLUnionType
-} from '../../type/definition';
+import { doTypesOverlap } from '../../utilities/typeComparators';
 import { typeFromAST } from '../../utilities/typeFromAST';
 import type { GraphQLType } from '../../type/definition';
 
@@ -74,22 +69,3 @@ function getFragmentType(context, name) {
   const frag = context.getFragment(name);
   return frag && typeFromAST(context.getSchema(), frag.typeCondition);
 }
-
-function doTypesOverlap(t1, t2) {
-  if (t1 === t2) {
-    return true;
-  }
-  if (t1 instanceof GraphQLObjectType) {
-    if (t2 instanceof GraphQLObjectType) {
-      return false;
-    }
-    return t2.getPossibleTypes().indexOf(t1) !== -1;
-  }
-  if (t1 instanceof GraphQLInterfaceType || t1 instanceof GraphQLUnionType) {
-    if (t2 instanceof GraphQLObjectType) {
-      return t1.getPossibleTypes().indexOf(t2) !== -1;
-    }
-    const t1TypeNames = keyMap(t1.getPossibleTypes(), type => type.name);
-    return t2.getPossibleTypes().some(type => t1TypeNames[type.name]);
-  }
-}