Allow providing directives to GraphQLSchema

src/type/__tests__/validation.js

@@ -189,6 +189,17 @@ describe('Type System: A Schema must have Object root types', () => {
     );
   });
 
+  it('rejects a Schema whose directives are incorrectly typed', () => {
+    expect(
+      () => new GraphQLSchema({
+        query: SomeObjectType,
+        directives: [ 'somedirective' ]
+      })
+    ).to.throw(
+      'Schema directives must be Array<GraphQLDirective> if provided but got: somedirective.'
+    );
+  });
+
 });
 
 describe('Type System: A Schema must contain uniquely named types', () => {

src/type/definition.js

@@ -488,6 +488,7 @@ export type GraphQLFieldConfigArgumentMap = {
 export type GraphQLArgumentConfig = {
   type: GraphQLInputType;
   defaultValue?: any;
+  description?: ?string;
 }
 
 export type GraphQLFieldConfigMap = {

src/type/directives.js

@@ -28,20 +28,20 @@ export class GraphQLDirective {
   constructor(config: GraphQLDirectiveConfig) {
     this.name = config.name;
     this.description = config.description;
-    this.args = config.args;
-    this.onOperation = config.onOperation;
-    this.onFragment = config.onFragment;
-    this.onField = config.onField;
+    this.args = config.args || [];
+    this.onOperation = Boolean(config.onOperation);
+    this.onFragment = Boolean(config.onFragment);
+    this.onField = Boolean(config.onField);
   }
 }
 
 type GraphQLDirectiveConfig = {
   name: string;
-  description?: string;
-  args: Array<GraphQLArgument>;
-  onOperation: boolean;
-  onFragment: boolean;
-  onField: boolean;
+  description?: ?string;
+  args?: ?Array<GraphQLArgument>;
+  onOperation?: ?boolean;
+  onFragment?: ?boolean;
+  onField?: ?boolean;
 }
 
 /**

src/type/schema.js

@@ -17,8 +17,11 @@ import {
   GraphQLNonNull
 } from './definition';
 import type { GraphQLType } from './definition';
-import { GraphQLIncludeDirective, GraphQLSkipDirective } from './directives';
-import type { GraphQLDirective } from './directives';
+import {
+  GraphQLDirective,
+  GraphQLIncludeDirective,
+  GraphQLSkipDirective
+} from './directives';
 import { __Schema } from './introspection';
 import find from '../jsutils/find';
 import invariant from '../jsutils/invariant';
@@ -40,30 +43,51 @@ import invariant from '../jsutils/invariant';
  *
  */
 export class GraphQLSchema {
-  _schemaConfig: GraphQLSchemaConfig;
-  _typeMap: TypeMap;
+  _queryType: GraphQLObjectType;
+  _mutationType: ?GraphQLObjectType;
+  _subscriptionType: ?GraphQLObjectType;
   _directives: Array<GraphQLDirective>;
+  _typeMap: TypeMap;
 
   constructor(config: GraphQLSchemaConfig) {
     invariant(
       typeof config === 'object',
       'Must provide configuration object.'
     );
+
     invariant(
       config.query instanceof GraphQLObjectType,
       `Schema query must be Object Type but got: ${config.query}.`
     );
+    this._queryType = config.query;
+
     invariant(
       !config.mutation || config.mutation instanceof GraphQLObjectType,
       `Schema mutation must be Object Type if provided but ` +
       `got: ${config.mutation}.`
     );
+    this._mutationType = config.mutation;
+
     invariant(
       !config.subscription || config.subscription instanceof GraphQLObjectType,
       `Schema subscription must be Object Type if provided but ` +
       `got: ${config.subscription}.`
     );
-    this._schemaConfig = config;
+    this._subscriptionType = config.subscription;
+
+    invariant(
+      !config.directives ||
+      Array.isArray(config.directives) && config.directives.every(
+        directive => directive instanceof GraphQLDirective
+      ),
+      `Schema directives must be Array<GraphQLDirective> if provided but ` +
+      `got: ${config.directives}.`
+    );
+    // Provide `@include() and `@skip()` directives by default.
+    this._directives = config.directives || [
+      GraphQLIncludeDirective,
+      GraphQLSkipDirective
+    ];
 
     // Build type map now to detect any errors within this schema.
     this._typeMap = [
@@ -85,15 +109,15 @@ export class GraphQLSchema {
   }
 
   getQueryType(): GraphQLObjectType {
-    return this._schemaConfig.query;
+    return this._queryType;
   }
 
   getMutationType(): ?GraphQLObjectType {
-    return this._schemaConfig.mutation;
+    return this._mutationType;
   }
 
   getSubscriptionType(): ?GraphQLObjectType {
-    return this._schemaConfig.subscription;
+    return this._subscriptionType;
   }
 
   getTypeMap(): TypeMap {
@@ -105,10 +129,7 @@ export class GraphQLSchema {
   }
 
   getDirectives(): Array<GraphQLDirective> {
-    return this._directives || (this._directives = [
-      GraphQLIncludeDirective,
-      GraphQLSkipDirective
-    ]);
+    return this._directives;
   }
 
   getDirective(name: string): ?GraphQLDirective {
@@ -122,6 +143,7 @@ type GraphQLSchemaConfig = {
   query: GraphQLObjectType;
   mutation?: ?GraphQLObjectType;
   subscription?: ?GraphQLObjectType;
+  directives?: ?Array<GraphQLDirective>;
 }
 
 function typeMapReducer(map: TypeMap, type: ?GraphQLType): TypeMap {

src/utilities/__tests__/buildClientSchema.js

@@ -28,6 +28,7 @@ import {
   GraphQLBoolean,
   GraphQLID,
 } from '../../';
+import { GraphQLDirective } from '../../type/directives';
 
 
 // Test property:
@@ -477,6 +478,31 @@ describe('Type System: build schema from introspection', () => {
     await testSchema(schema);
   });
 
+  it('builds a schema with custom directives', async () => {
+
+    var schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Simple',
+        description: 'This is a simple type',
+        fields: {
+          string: {
+            type: GraphQLString,
+            description: 'This is a string field'
+          }
+        }
+      }),
+      directives: [
+        new GraphQLDirective({
+          name: 'customDirective',
+          description: 'This is a custom directive',
+          onField: true,
+        })
+      ]
+    });
+
+    await testSchema(schema);
+  });
+
   it('cannot use client schema for general execution', async () => {
     var customScalar = new GraphQLScalarType({
       name: 'CustomScalar',

src/utilities/buildClientSchema.js

@@ -36,6 +36,8 @@ import {
   GraphQLID
 } from '../type/scalars';
 
+import { GraphQLDirective } from '../type/directives';
+
 import { TypeKind } from '../type/introspection';
 
 import type {
@@ -292,19 +294,35 @@ export function buildClientSchema(
     return keyValMap(
       inputValueIntrospections,
       inputValue => inputValue.name,
-      inputValue => {
-        var description = inputValue.description;
-        var type = getInputType(inputValue.type);
-        var defaultValue = inputValue.defaultValue ?
-          valueFromAST(parseValue(inputValue.defaultValue), type) :
-          null;
-        return { description, type, defaultValue };
-      }
+      buildInputValue
     );
   }
 
+  function buildInputValue(inputValueIntrospection) {
+    var type = getInputType(inputValueIntrospection.type);
+    var defaultValue = inputValueIntrospection.defaultValue ?
+      valueFromAST(parseValue(inputValueIntrospection.defaultValue), type) :
+      null;
+    return {
+      name: inputValueIntrospection.name,
+      description: inputValueIntrospection.description,
+      type,
+      defaultValue,
+    };
+  }
+
+  function buildDirective(directiveIntrospection) {
+    return new GraphQLDirective({
+      name: directiveIntrospection.name,
+      description: directiveIntrospection.description,
+      args: directiveIntrospection.args.map(buildInputValue),
+      onOperation: directiveIntrospection.onOperation,
+      onFragment: directiveIntrospection.onFragment,
+      onField: directiveIntrospection.onField,
+    });
+  }
+
   // TODO: deprecation
-  // TODO: directives
 
   // Iterate through all types, getting the type definition for each, ensuring
   // that any type not directly referenced by a field will get created.
@@ -313,20 +331,27 @@ export function buildClientSchema(
   );
 
   // Get the root Query, Mutation, and Subscription types.
-  var queryType = getType(schemaIntrospection.queryType);
+  var queryType = getObjectType(schemaIntrospection.queryType);
+
   var mutationType = schemaIntrospection.mutationType ?
-    getType(schemaIntrospection.mutationType) :
+    getObjectType(schemaIntrospection.mutationType) :
     null;
+
   var subscriptionType = schemaIntrospection.subscriptionType ?
-    getType(schemaIntrospection.subscriptionType) :
+    getObjectType(schemaIntrospection.subscriptionType) :
     null;
 
+  // Get the directives supported by Introspection, assuming empty-set if
+  // directives were not queried for.
+  var directives = schemaIntrospection.directives ?
+    schemaIntrospection.directives.map(buildDirective) :
+    [];
+
   // Then produce and return a Schema with these types.
-  var schema = new GraphQLSchema({
-    query: (queryType: any),
-    mutation: (mutationType: any),
-    subscription: (subscriptionType: any)
+  return new GraphQLSchema({
+    query: queryType,
+    mutation: mutationType,
+    subscription: subscriptionType,
+    directives,
   });
-
-  return schema;
 }

src/validation/__tests__/KnownDirectives.js

@@ -104,11 +104,13 @@ describe('Validate: Known directives', () => {
   it('with misplaced directives', () => {
     expectFailsRule(KnownDirectives, `
       query Foo @include(if: true) {
-        name
-        ...Frag
+        name @operationOnly
+        ...Frag @operationOnly
       }
     `, [
-      misplacedDirective('include', 'operation', 2, 17)
+      misplacedDirective('include', 'operation', 2, 17),
+      misplacedDirective('operationOnly', 'field', 3, 14),
+      misplacedDirective('operationOnly', 'fragment', 4, 17),
     ]);
   });
 

src/validation/__tests__/harness.js

@@ -26,6 +26,11 @@ import {
   GraphQLBoolean,
   GraphQLID
 } from '../../type';
+import {
+  GraphQLDirective,
+  GraphQLIncludeDirective,
+  GraphQLSkipDirective,
+} from '../../type/directives';
 
 
 var Being = new GraphQLInterfaceType({
@@ -288,7 +293,15 @@ var QueryRoot = new GraphQLObjectType({
 });
 
 var defaultSchema = new GraphQLSchema({
-  query: QueryRoot
+  query: QueryRoot,
+  directives: [
+    new GraphQLDirective({
+      name: 'operationOnly',
+      onOperation: true
+    }),
+    GraphQLIncludeDirective,
+    GraphQLSkipDirective,
+  ]
 });
 
 function expectValid(schema, rules, queryString) {