Adapt "KnownDirectives" to work with SDL

Author: IvanGoncharov

src/utilities/__tests__/buildASTSchema-test.js

@@ -787,6 +787,24 @@ describe('Schema Builder', () => {
     const errors = validateSchema(schema);
     expect(errors.length).to.equal(0);
   });
+
+  it('Rejects invalid SDL', () => {
+    const doc = parse(`
+      type Query {
+        foo: String @unknown
+      }
+    `);
+    expect(() => buildASTSchema(doc)).to.throw('Unknown directive "unknown".');
+  });
+
+  it('Allows to disable SDL validation', () => {
+    const body = `
+      type Query {
+        foo: String @unknown
+      }
+    `;
+    buildSchema(body, { assumeValidSDL: true });
+  });
 });
 
 describe('Failures', () => {

src/utilities/__tests__/extendSchema-test.js

@@ -1018,6 +1018,22 @@ describe('extendSchema', () => {
     expect(isScalarType(arg1.type)).to.equal(true);
   });
 
+  it('Rejects invalid SDL', () => {
+    const sdl = `
+      extend schema @unknown
+    `;
+    expect(() => extendTestSchema(sdl)).to.throw(
+      'Unknown directive "unknown".',
+    );
+  });
+
+  it('Allows to disable SDL validation', () => {
+    const sdl = `
+      extend schema @unknown
+    `;
+    extendTestSchema(sdl, { assumeValidSDL: true });
+  });
+
   it('does not allow replacing a default directive', () => {
     const sdl = `
       directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD

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),
+      ]);
     });
   });
 });

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'],
-    }),
   ],
 });
 

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,
+          ]),
         );
       }
     },

src/validation/specifiedRules.js

@@ -130,5 +130,6 @@ import { LoneSchemaDefinition } from './rules/LoneSchemaDefinition';
 
 export const specifiedSDLRules: Array<(SDLValidationContext) => ASTVisitor> = [
   LoneSchemaDefinition,
+  KnownDirectives,
   UniqueDirectivesPerLocation,
 ];