Better Predicates

src/execution/__tests__/executor-test.js

@@ -39,7 +39,7 @@ describe('Execute: Handles basic execution tasks', () => {
       execute({
         document: parse('{ field }'),
       }),
-    ).to.throw('Must provide schema');
+    ).to.throw('Expected undefined to be a GraphQL schema.');
   });
 
   it('accepts an object with named properties as arguments', async () => {

src/execution/execute.js

@@ -22,12 +22,15 @@ import {
   getDirectiveValues,
 } from './values';
 import {
-  GraphQLObjectType,
+  isObjectType,
   isAbstractType,
   isLeafType,
+  isListType,
+  isNonNullType,
 } from '../type/definition';
-import { GraphQLList, GraphQLNonNull } from '../type/wrappers';
+import type { GraphQLList } from '../type/wrappers';
 import type {
+  GraphQLObjectType,
   GraphQLOutputType,
   GraphQLLeafType,
   GraphQLAbstractType,
@@ -807,7 +810,7 @@ function completeValueCatchingError(
 ): mixed {
   // If the field type is non-nullable, then it is resolved without any
   // protection from errors, however it still properly locates the error.
-  if (returnType instanceof GraphQLNonNull) {
+  if (isNonNullType(returnType)) {
     return completeValueWithLocatedError(
       exeContext,
       returnType,
@@ -934,7 +937,7 @@ function completeValue(
 
   // If field type is NonNull, complete for inner type, and throw field error
   // if result is null.
-  if (returnType instanceof GraphQLNonNull) {
+  if (isNonNullType(returnType)) {
     const completed = completeValue(
       exeContext,
       returnType.ofType,
@@ -959,7 +962,7 @@ function completeValue(
   }
 
   // If field type is List, complete each item in the list with the inner type
-  if (returnType instanceof GraphQLList) {
+  if (isListType(returnType)) {
     return completeListValue(
       exeContext,
       returnType,
@@ -990,7 +993,7 @@ function completeValue(
   }
 
   // If field type is Object, execute and complete all sub-selections.
-  if (returnType instanceof GraphQLObjectType) {
+  if (isObjectType(returnType)) {
     return completeObjectValue(
       exeContext,
       returnType,
@@ -1002,6 +1005,7 @@ function completeValue(
   }
 
   // Not reachable. All possible output types have been considered.
+  /* istanbul ignore next */
   throw new Error(
     `Cannot complete value of unexpected type "${String(
       (returnType: empty),
@@ -1015,7 +1019,7 @@ function completeValue(
  */
 function completeListValue(
   exeContext: ExecutionContext,
-  returnType: GraphQLList<*>,
+  returnType: GraphQLList<GraphQLOutputType>,
   fieldNodes: $ReadOnlyArray<FieldNode>,
   info: GraphQLResolveInfo,
   path: ResponsePath,
@@ -1138,7 +1142,7 @@ function ensureValidRuntimeType(
       ? exeContext.schema.getType(runtimeTypeOrName)
       : runtimeTypeOrName;
 
-  if (!(runtimeType instanceof GraphQLObjectType)) {
+  if (!isObjectType(runtimeType)) {
     throw new GraphQLError(
       `Abstract type ${returnType.name} must resolve to an Object type at ` +
         `runtime for field ${info.parentType.name}.${info.fieldName} with ` +

src/execution/values.js

@@ -17,9 +17,7 @@ import { valueFromAST } from '../utilities/valueFromAST';
 import { isValidLiteralValue } from '../utilities/isValidLiteralValue';
 import * as Kind from '../language/kinds';
 import { print } from '../language/printer';
-import { isInputType } from '../type/definition';
-import { GraphQLNonNull } from '../type/wrappers';
-
+import { isInputType, isNonNullType } from '../type/definition';
 import type { ObjMap } from '../jsutils/ObjMap';
 import type { GraphQLField } from '../type/definition';
 import type { GraphQLDirective } from '../type/directives';
@@ -69,7 +67,7 @@ export function getVariableValues(
     } else {
       const value = inputs[varName];
       if (isInvalid(value)) {
-        if (varType instanceof GraphQLNonNull) {
+        if (isNonNullType(varType)) {
           errors.push(
             new GraphQLError(
               `Variable "$${varName}" of required type ` +
@@ -134,7 +132,7 @@ export function getArgumentValues(
     if (!argumentNode) {
       if (!isInvalid(defaultValue)) {
         coercedValues[name] = defaultValue;
-      } else if (argType instanceof GraphQLNonNull) {
+      } else if (isNonNullType(argType)) {
         throw new GraphQLError(
           `Argument "${name}" of required type ` +
             `"${String(argType)}" was not provided.`,
@@ -154,7 +152,7 @@ export function getArgumentValues(
         coercedValues[name] = variableValues[variableName];
       } else if (!isInvalid(defaultValue)) {
         coercedValues[name] = defaultValue;
-      } else if (argType instanceof GraphQLNonNull) {
+      } else if (isNonNullType(argType)) {
         throw new GraphQLError(
           `Argument "${name}" of required type "${String(argType)}" was ` +
             `provided the variable "$${variableName}" which was not provided ` +

src/index.js

@@ -79,23 +79,45 @@ export {
   __EnumValue,
   __TypeKind,
   // Predicates
+  isSchema,
+  isDirective,
   isType,
+  isScalarType,
+  isObjectType,
+  isInterfaceType,
+  isUnionType,
+  isEnumType,
+  isInputObjectType,
+  isListType,
+  isNonNullType,
   isInputType,
   isOutputType,
   isLeafType,
   isCompositeType,
   isAbstractType,
+  isWrappingType,
+  isNullableType,
   isNamedType,
   isSpecifiedScalarType,
   isIntrospectionType,
   isSpecifiedDirective,
   // Assertions
   assertType,
+  assertScalarType,
+  assertObjectType,
+  assertInterfaceType,
+  assertUnionType,
+  assertEnumType,
+  assertInputObjectType,
+  assertListType,
+  assertNonNullType,
   assertInputType,
   assertOutputType,
   assertLeafType,
   assertCompositeType,
   assertAbstractType,
+  assertWrappingType,
+  assertNullableType,
   assertNamedType,
   // Un-modifiers
   getNullableType,
@@ -112,6 +134,7 @@ export type {
   GraphQLLeafType,
   GraphQLCompositeType,
   GraphQLAbstractType,
+  GraphQLWrappingType,
   GraphQLNullableType,
   GraphQLNamedType,
   Thunk,

src/jsutils/instanceOf.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+/**
+ * A replacement for instanceof which includes an error warning when multi-realm
+ * constructors are detected.
+ */
+declare function instanceOf(
+  value: mixed,
+  constructor: mixed,
+): boolean %checks(value instanceof constructor);
+
+// eslint-disable-next-line no-redeclare
+export default function instanceOf(value, constructor) {
+  if (value instanceof constructor) {
+    return true;
+  }
+  if (value) {
+    const valueConstructor = value.constructor;
+    if (valueConstructor && valueConstructor.name === constructor.name) {
+      throw new Error(
+        `Cannot use ${constructor.name} "${value}" from another module or realm.
+
+Ensure that there is only one instance of "graphql" in the node_modules
+directory. If different versions of "graphql" are the dependencies of other
+relied on modules, use "resolutions" to ensure only one version is installed.
+
+https://yarnpkg.com/en/docs/selective-version-resolutions
+
+Duplicate "graphql" modules cannot be used at the same time since different
+versions may have different capabilities and behavior. The data from one
+version used in the function from another could produce confusing and
+spurious results.`,
+      );
+    }
+  }
+  return false;
+}

src/jsutils/invariant.js

@@ -8,6 +8,7 @@
  */
 
 export default function invariant(condition: mixed, message: string) {
+  /* istanbul ignore else */
   if (!condition) {
     throw new Error(message);
   }

src/subscription/__tests__/subscribe-test.js

@@ -313,12 +313,12 @@ describe('Subscription Initialization Phase', () => {
 
     await expectPromiseToThrow(
       () => subscribe(null, document),
-      'Must provide schema.',
+      'Expected null to be a GraphQL schema.',
     );
 
     await expectPromiseToThrow(
       () => subscribe({ document }),
-      'Must provide schema.',
+      'Expected undefined to be a GraphQL schema.',
     );
   });
 

src/type/__tests__/definition-test.js

@@ -23,7 +23,7 @@ import {
 import { describe, it } from 'mocha';
 import { expect } from 'chai';
 
-import { isInputType, isOutputType } from '../definition';
+import { isObjectType, isInputType, isOutputType } from '../definition';
 
 const BlogImage = new GraphQLObjectType({
   name: 'Image',
@@ -118,19 +118,19 @@ describe('Type System: Example', () => {
     const articleFieldType = articleField ? articleField.type : null;
 
     const titleField =
-      articleFieldType instanceof GraphQLObjectType &&
+      isObjectType(articleFieldType) &&
       articleFieldType.getFields()[('title': string)];
     expect(titleField && titleField.name).to.equal('title');
     expect(titleField && titleField.type).to.equal(GraphQLString);
     expect(titleField && titleField.type.name).to.equal('String');
 
     const authorField =
-      articleFieldType instanceof GraphQLObjectType &&
+      isObjectType(articleFieldType) &&
       articleFieldType.getFields()[('author': string)];
 
     const authorFieldType = authorField ? authorField.type : null;
     const recentArticleField =
-      authorFieldType instanceof GraphQLObjectType &&
+      isObjectType(authorFieldType) &&
       authorFieldType.getFields()[('recentArticle': string)];
 
     expect(recentArticleField && recentArticleField.type).to.equal(BlogArticle);
@@ -374,12 +374,6 @@ describe('Type System: Example', () => {
     });
   });
 
-  it('prohibits nesting NonNull inside NonNull', () => {
-    expect(() => GraphQLNonNull(GraphQLNonNull(GraphQLInt))).to.throw(
-      'Can only create NonNull of a Nullable GraphQLType but got: Int!.',
-    );
-  });
-
   it('prohibits putting non-Object types in unions', () => {
     const badUnionTypes = [
       GraphQLInt,
@@ -476,7 +470,7 @@ describe('Type System: Example', () => {
   });
 });
 
-describe('Type System: List must accept GraphQL types', () => {
+describe('Type System: List must accept only types', () => {
   const types = [
     GraphQLString,
     ScalarType,
@@ -506,7 +500,7 @@ describe('Type System: List must accept GraphQL types', () => {
   });
 });
 
-describe('Type System: NonNull must accept GraphQL types', () => {
+describe('Type System: NonNull must only accept non-nullable types', () => {
   const nullableTypes = [
     GraphQLString,
     ScalarType,
@@ -536,7 +530,7 @@ describe('Type System: NonNull must accept GraphQL types', () => {
   notNullableTypes.forEach(type => {
     it(`rejects a non-type as nullable type of non-null: ${type}`, () => {
       expect(() => GraphQLNonNull(type)).to.throw(
-        `Can only create NonNull of a Nullable GraphQLType but got: ${type}.`,
+        `Expected ${type} to be a GraphQL nullable type.`,
       );
     });
   });