Adapt "KnownDirectives" to work with SDL

IvanGoncharov · IvanGoncharov · commit 2aae7ac35167 · 2018-07-30T18:12:06.000+03:00
diff --git a/src/validation/__tests__/KnownDirectives-test.js b/src/validation/__tests__/KnownDirectives-test.js
@@ -6,13 +6,24 @@
  */
 
 import { describe, it } from 'mocha';
-import { expectPassesRule, expectFailsRule } from './harness';
+import { buildSchema } from '../../utilities';
+import {
+  expectPassesRule,
+  expectFailsRule,
+  expectSDLErrorsFromRule,
+} from './harness';
+
 import {
   KnownDirectives,
   unknownDirectiveMessage,
   misplacedDirectiveMessage,
 } from '../rules/KnownDirectives';
 
+const expectSDLErrors = expectSDLErrorsFromRule.bind(
+  undefined,
+  KnownDirectives,
+);
+
 function unknownDirective(directiveName, line, column) {
   return {
     message: unknownDirectiveMessage(directiveName),
@@ -27,6 +38,20 @@ function misplacedDirective(directiveName, placement, line, column) {
   };
 }
 
+const schemaWithSDLDirectives = buildSchema(`
+  directive @onSchema on SCHEMA
+  directive @onScalar on SCALAR
+  directive @onObject on OBJECT
+  directive @onFieldDefinition on FIELD_DEFINITION
+  directive @onArgumentDefinition on ARGUMENT_DEFINITION
+  directive @onInterface on INTERFACE
+  directive @onUnion on UNION
+  directive @onEnum on ENUM
+  directive @onEnumValue on ENUM_VALUE
+  directive @onInputObject on INPUT_OBJECT
+  directive @onInputFieldDefinition on INPUT_FIELD_DEFINITION
+`);
+
 describe('Validate: Known directives', () => {
   it('with no directives', () => {
     expectPassesRule(
@@ -138,10 +163,36 @@ describe('Validate: Known directives', () => {
     );
   });
 
-  describe('within schema language', () => {
+  describe('within SDL', () => {
+    it('with directive defined inside SDL', () => {
+      expectSDLErrors(`
+        type Query {
+          foo: String @test
+        }
+
+        directive @test on FIELD_DEFINITION
+      `).to.deep.equal([]);
+    });
+
+    it('with standard directive', () => {
+      expectSDLErrors(`
+        type Query {
+          foo: String @deprecated
+        }
+      `).to.deep.equal([]);
+    });
+
+    it('with overrided standard directive', () => {
+      expectSDLErrors(`
+        schema @deprecated {
+          query: Query
+        }
+        directive @deprecated on SCHEMA
+      `).to.deep.equal([]);
+    });
+
     it('with well placed directives', () => {
-      expectPassesRule(
-        KnownDirectives,
+      expectSDLErrors(
         `
         type MyObj implements MyInterface @onObject {
           myField(myArg: Int @onArgumentDefinition): String @onFieldDefinition
@@ -180,13 +231,13 @@ describe('Validate: Known directives', () => {
         }
 
         extend schema @onSchema
-      `,
-      );
+        `,
+        schemaWithSDLDirectives,
+      ).to.deep.equal([]);
     });
 
     it('with misplaced directives', () => {
-      expectFailsRule(
-        KnownDirectives,
+      expectSDLErrors(
         `
         type MyObj implements MyInterface @onInterface {
           myField(myArg: Int @onInputFieldDefinition): String @onInputFieldDefinition
@@ -213,49 +264,39 @@ describe('Validate: Known directives', () => {
         }
 
         extend schema @onObject
-      `,
-        [
-          misplacedDirective('onInterface', 'OBJECT', 2, 43),
-          misplacedDirective(
-            'onInputFieldDefinition',
-            'ARGUMENT_DEFINITION',
-            3,
-            30,
-          ),
-          misplacedDirective(
-            'onInputFieldDefinition',
-            'FIELD_DEFINITION',
-            3,
-            63,
-          ),
-          misplacedDirective('onEnum', 'SCALAR', 6, 25),
-          misplacedDirective('onObject', 'INTERFACE', 8, 31),
-          misplacedDirective(
-            'onInputFieldDefinition',
-            'ARGUMENT_DEFINITION',
-            9,
-            30,
-          ),
-          misplacedDirective(
-            'onInputFieldDefinition',
-            'FIELD_DEFINITION',
-            9,
-            63,
-          ),
-          misplacedDirective('onEnumValue', 'UNION', 12, 23),
-          misplacedDirective('onScalar', 'ENUM', 14, 21),
-          misplacedDirective('onUnion', 'ENUM_VALUE', 15, 20),
-          misplacedDirective('onEnum', 'INPUT_OBJECT', 18, 23),
-          misplacedDirective(
-            'onArgumentDefinition',
-            'INPUT_FIELD_DEFINITION',
-            19,
-            24,
-          ),
-          misplacedDirective('onObject', 'SCHEMA', 22, 16),
-          misplacedDirective('onObject', 'SCHEMA', 26, 23),
-        ],
-      );
+        `,
+        schemaWithSDLDirectives,
+      ).to.deep.equal([
+        misplacedDirective('onInterface', 'OBJECT', 2, 43),
+        misplacedDirective(
+          'onInputFieldDefinition',
+          'ARGUMENT_DEFINITION',
+          3,
+          30,
+        ),
+        misplacedDirective('onInputFieldDefinition', 'FIELD_DEFINITION', 3, 63),
+        misplacedDirective('onEnum', 'SCALAR', 6, 25),
+        misplacedDirective('onObject', 'INTERFACE', 8, 31),
+        misplacedDirective(
+          'onInputFieldDefinition',
+          'ARGUMENT_DEFINITION',
+          9,
+          30,
+        ),
+        misplacedDirective('onInputFieldDefinition', 'FIELD_DEFINITION', 9, 63),
+        misplacedDirective('onEnumValue', 'UNION', 12, 23),
+        misplacedDirective('onScalar', 'ENUM', 14, 21),
+        misplacedDirective('onUnion', 'ENUM_VALUE', 15, 20),
+        misplacedDirective('onEnum', 'INPUT_OBJECT', 18, 23),
+        misplacedDirective(
+          'onArgumentDefinition',
+          'INPUT_FIELD_DEFINITION',
+          19,
+          24,
+        ),
+        misplacedDirective('onObject', 'SCHEMA', 22, 16),
+        misplacedDirective('onObject', 'SCHEMA', 26, 23),
+      ]);
     });
   });
 });
diff --git a/src/validation/__tests__/harness.js b/src/validation/__tests__/harness.js
@@ -374,50 +374,6 @@ export const testSchema = new GraphQLSchema({
       name: 'onInlineFragment',
       locations: ['INLINE_FRAGMENT'],
     }),
-    new GraphQLDirective({
-      name: 'onSchema',
-      locations: ['SCHEMA'],
-    }),
-    new GraphQLDirective({
-      name: 'onScalar',
-      locations: ['SCALAR'],
-    }),
-    new GraphQLDirective({
-      name: 'onObject',
-      locations: ['OBJECT'],
-    }),
-    new GraphQLDirective({
-      name: 'onFieldDefinition',
-      locations: ['FIELD_DEFINITION'],
-    }),
-    new GraphQLDirective({
-      name: 'onArgumentDefinition',
-      locations: ['ARGUMENT_DEFINITION'],
-    }),
-    new GraphQLDirective({
-      name: 'onInterface',
-      locations: ['INTERFACE'],
-    }),
-    new GraphQLDirective({
-      name: 'onUnion',
-      locations: ['UNION'],
-    }),
-    new GraphQLDirective({
-      name: 'onEnum',
-      locations: ['ENUM'],
-    }),
-    new GraphQLDirective({
-      name: 'onEnumValue',
-      locations: ['ENUM_VALUE'],
-    }),
-    new GraphQLDirective({
-      name: 'onInputObject',
-      locations: ['INPUT_OBJECT'],
-    }),
-    new GraphQLDirective({
-      name: 'onInputFieldDefinition',
-      locations: ['INPUT_FIELD_DEFINITION'],
-    }),
   ],
 });
 
diff --git a/src/validation/rules/KnownDirectives.js b/src/validation/rules/KnownDirectives.js
@@ -7,12 +7,15 @@
  * @flow strict
  */
 
-import type { ValidationContext } from '../ValidationContext';
+import type {
+  ValidationContext,
+  SDLValidationContext,
+} from '../ValidationContext';
 import { GraphQLError } from '../../error';
-import find from '../../jsutils/find';
 import { Kind } from '../../language/kinds';
 import { DirectiveLocation } from '../../language/directiveLocation';
 import type { ASTVisitor } from '../../language/visitor';
+import { specifiedDirectives } from '../../type/directives';
 
 export function unknownDirectiveMessage(directiveName: string): string {
   return `Unknown directive "${directiveName}".`;
@@ -31,29 +34,42 @@ export function misplacedDirectiveMessage(
  * A GraphQL document is only valid if all `@directives` are known by the
  * schema and legally positioned.
  */
-export function KnownDirectives(context: ValidationContext): ASTVisitor {
+export function KnownDirectives(
+  context: ValidationContext | SDLValidationContext,
+): ASTVisitor {
+  const locationsMap = Object.create(null);
+  const schema = context.getSchema();
+  const definedDirectives = schema
+    ? schema.getDirectives()
+    : specifiedDirectives;
+  for (const directive of definedDirectives) {
+    locationsMap[directive.name] = directive.locations;
+  }
+
   return {
+    Document(node) {
+      for (const def of node.definitions) {
+        if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+          locationsMap[def.name.value] = def.locations.map(name => name.value);
+        }
+      }
+    },
     Directive(node, key, parent, path, ancestors) {
-      const directiveDef = find(
-        context.getSchema().getDirectives(),
-        def => def.name === node.name.value,
-      );
-      if (!directiveDef) {
+      const name = node.name.value;
+      const locations = locationsMap[name];
+
+      if (!locations) {
         context.reportError(
-          new GraphQLError(unknownDirectiveMessage(node.name.value), [node]),
+          new GraphQLError(unknownDirectiveMessage(name), [node]),
         );
         return;
       }
       const candidateLocation = getDirectiveLocationForASTPath(ancestors);
-      if (
-        candidateLocation &&
-        directiveDef.locations.indexOf(candidateLocation) === -1
-      ) {
+      if (candidateLocation && locations.indexOf(candidateLocation) === -1) {
         context.reportError(
-          new GraphQLError(
-            misplacedDirectiveMessage(node.name.value, candidateLocation),
-            [node],
-          ),
+          new GraphQLError(misplacedDirectiveMessage(name, candidateLocation), [
+            node,
+          ]),
         );
       }
     },
