Add missing assertDirective and assertSchema (#1580)

Author: IvanGoncharov

src/index.js

@@ -104,6 +104,8 @@ export {
   isIntrospectionType,
   isSpecifiedDirective,
   // Assertions
+  assertSchema,
+  assertDirective,
   assertType,
   assertScalarType,
   assertObjectType,

src/type/directives.js

@@ -17,6 +17,7 @@ import defineToStringTag from '../jsutils/defineToStringTag';
 import defineToJSON from '../jsutils/defineToJSON';
 import instanceOf from '../jsutils/instanceOf';
 import invariant from '../jsutils/invariant';
+import inspect from '../jsutils/inspect';
 import type { DirectiveDefinitionNode } from '../language/ast';
 import {
   DirectiveLocation,
@@ -34,6 +35,14 @@ export function isDirective(directive) {
   return instanceOf(directive, GraphQLDirective);
 }
 
+export function assertDirective(directive: mixed): GraphQLDirective {
+  invariant(
+    isDirective(directive),
+    `Expected ${inspect(directive)} to be a GraphQL directive.`,
+  );
+  return directive;
+}
+
 /**
  * Directives are used by the GraphQL runtime as a way of modifying execution
  * behavior. Type system creators will usually not create these directly.

src/type/index.js

@@ -10,6 +10,8 @@
 export {
   // Predicate
   isSchema,
+  // Assertion
+  assertSchema,
   // GraphQL Schema definition
   GraphQLSchema,
 } from './schema';
@@ -73,6 +75,8 @@ export {
 export {
   // Predicate
   isDirective,
+  // Assertion
+  assertDirective,
   // Directives Definition
   GraphQLDirective,
   // Built-in Directives defined by the Spec

src/type/schema.js

@@ -50,6 +50,14 @@ export function isSchema(schema) {
   return instanceOf(schema, GraphQLSchema);
 }
 
+export function assertSchema(schema: mixed): GraphQLSchema {
+  invariant(
+    isSchema(schema),
+    `Expected ${inspect(schema)} to be a GraphQL schema.`,
+  );
+  return schema;
+}
+
 /**
  * Schema Definition
  *

src/type/validate.js

@@ -28,11 +28,10 @@ import type {
 import { isDirective } from './directives';
 import type { GraphQLDirective } from './directives';
 import { isIntrospectionType } from './introspection';
-import { isSchema } from './schema';
+import { assertSchema } from './schema';
 import type { GraphQLSchema } from './schema';
 import inspect from '../jsutils/inspect';
 import find from '../jsutils/find';
-import invariant from '../jsutils/invariant';
 import objectValues from '../jsutils/objectValues';
 import { GraphQLError } from '../error/GraphQLError';
 import type {
@@ -57,10 +56,7 @@ export function validateSchema(
   schema: GraphQLSchema,
 ): $ReadOnlyArray<GraphQLError> {
   // First check to ensure the provided value is in fact a GraphQLSchema.
-  invariant(
-    isSchema(schema),
-    `Expected ${inspect(schema)} to be a GraphQL schema.`,
-  );
+  assertSchema(schema);
 
   // If this Schema has already been validated, return the previous results.
   if (schema.__validationErrors) {

src/utilities/__tests__/buildASTSchema-test.js

@@ -16,6 +16,7 @@ import { buildASTSchema, buildSchema } from '../buildASTSchema';
 import dedent from '../../jsutils/dedent';
 import { Kind } from '../../language/kinds';
 import {
+  assertDirective,
   assertObjectType,
   assertInputObjectType,
   assertEnumType,
@@ -716,8 +717,7 @@ describe('Schema Builder', () => {
     const testInterface = assertInterfaceType(schema.getType('TestInterface'));
     const testType = assertObjectType(schema.getType('TestType'));
     const testScalar = assertScalarType(schema.getType('TestScalar'));
-    const testDirective = schema.getDirective('test');
-    invariant(testDirective);
+    const testDirective = assertDirective(schema.getDirective('test'));
 
     const restoredSchemaAST = {
       kind: Kind.DOCUMENT,

src/utilities/__tests__/extendSchema-test.js

@@ -17,6 +17,7 @@ import { printSchema } from '../schemaPrinter';
 import { Kind } from '../../language/kinds';
 import { graphqlSync } from '../../';
 import {
+  assertDirective,
   assertObjectType,
   assertInputObjectType,
   assertEnumType,
@@ -325,8 +326,7 @@ describe('extendSchema', () => {
     const inputField = queryType.getFields().someInput;
     expect(inputField).to.have.nested.property('args[0].type', someInputType);
 
-    const fooDirective = extendedSchema.getDirective('foo');
-    invariant(fooDirective);
+    const fooDirective = assertDirective(extendedSchema.getDirective('foo'));
     expect(fooDirective.args[0].type).to.equal(someInputType);
   });
 
@@ -429,8 +429,9 @@ describe('extendSchema', () => {
     const testInterface = assertInterfaceType(
       extendedTwiceSchema.getType('TestInterface'),
     );
-    const testDirective = extendedTwiceSchema.getDirective('test');
-    invariant(testDirective);
+    const testDirective = assertDirective(
+      extendedTwiceSchema.getDirective('test'),
+    );
 
     expect(testType).to.include({ extensionASTNodes: undefined });
     expect(testEnum).to.include({ extensionASTNodes: undefined });
@@ -1051,8 +1052,9 @@ describe('extendSchema', () => {
       directive @profile(enable: Boolean! tag: String) on QUERY | FIELD
     `);
 
-    const extendedDirective = extendedSchema.getDirective('profile');
-    invariant(extendedDirective);
+    const extendedDirective = assertDirective(
+      extendedSchema.getDirective('profile'),
+    );
     expect(extendedDirective.locations).to.deep.equal(['QUERY', 'FIELD']);
 
     expect(extendedDirective.args).to.have.lengthOf(2);

src/utilities/extendSchema.js

@@ -14,7 +14,7 @@ import objectValues from '../jsutils/objectValues';
 import { ASTDefinitionBuilder } from './buildASTSchema';
 import { assertValidSDLExtension } from '../validation/validate';
 import { GraphQLError } from '../error/GraphQLError';
-import { isSchema, GraphQLSchema } from '../type/schema';
+import { assertSchema, GraphQLSchema } from '../type/schema';
 import { isIntrospectionType } from '../type/introspection';
 import { isSpecifiedScalarType } from '../type/scalars';
 
@@ -105,7 +105,7 @@ export function extendSchema(
   documentAST: DocumentNode,
   options?: Options,
 ): GraphQLSchema {
-  invariant(isSchema(schema), 'Must provide valid GraphQLSchema');
+  assertSchema(schema);
 
   invariant(
     documentAST && documentAST.kind === Kind.DOCUMENT,