Validate directive arguments inside SDL

IvanGoncharov · IvanGoncharov · commit 5f56c7358979 · 2018-08-27T16:19:02.000+03:00
diff --git a/src/validation/rules/KnownArgumentNames.js b/src/validation/rules/KnownArgumentNames.js
@@ -7,12 +7,16 @@
  * @flow strict
  */
 
-import type { ValidationContext } from '../ValidationContext';
+import type {
+  ValidationContext,
+  SDLValidationContext,
+} from '../ValidationContext';
 import { GraphQLError } from '../../error/GraphQLError';
 import type { ASTVisitor } from '../../language/visitor';
 import suggestionList from '../../jsutils/suggestionList';
 import quotedOrList from '../../jsutils/quotedOrList';
 import { Kind } from '../../language/kinds';
+import { specifiedDirectives } from '../../type/directives';
 
 export function unknownArgMessage(
   argName: string,
@@ -49,48 +53,73 @@ export function unknownDirectiveArgMessage(
  */
 export function KnownArgumentNames(context: ValidationContext): ASTVisitor {
   return {
-    Argument(node, key, parent, path, ancestors) {
+    ...KnownArgumentNamesOnDirectives(context),
+    Argument(node) {
+      const argName = node.name.value;
       const argDef = context.getArgument();
-      if (!argDef) {
-        const argumentOf = ancestors[ancestors.length - 1];
-        if (argumentOf.kind === Kind.FIELD) {
-          const fieldDef = context.getFieldDef();
-          const parentType = context.getParentType();
-          if (fieldDef && parentType) {
-            context.reportError(
-              new GraphQLError(
-                unknownArgMessage(
-                  node.name.value,
-                  fieldDef.name,
-                  parentType.name,
-                  suggestionList(
-                    node.name.value,
-                    fieldDef.args.map(arg => arg.name),
-                  ),
-                ),
-                [node],
-              ),
-            );
-          }
-        } else if (argumentOf.kind === Kind.DIRECTIVE) {
-          const directive = context.getDirective();
-          if (directive) {
+      const fieldDef = context.getFieldDef();
+      const parentType = context.getParentType();
+      if (!argDef && fieldDef && parentType) {
+        context.reportError(
+          new GraphQLError(
+            unknownArgMessage(
+              argName,
+              fieldDef.name,
+              parentType.name,
+              suggestionList(argName, fieldDef.args.map(arg => arg.name)),
+            ),
+            [node],
+          ),
+        );
+      }
+    },
+  };
+}
+
+// @internal
+export function KnownArgumentNamesOnDirectives(
+  context: ValidationContext | SDLValidationContext,
+): ASTVisitor {
+  const directiveArgs = Object.create(null);
+
+  const schema = context.getSchema();
+  const definedDirectives = schema
+    ? schema.getDirectives()
+    : specifiedDirectives;
+  for (const directive of definedDirectives) {
+    directiveArgs[directive.name] = directive.args.map(arg => arg.name);
+  }
+
+  const astDefinitions = context.getDocument().definitions;
+  for (const def of astDefinitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      directiveArgs[def.name.value] = def.arguments
+        ? def.arguments.map(arg => arg.name.value)
+        : [];
+    }
+  }
+
+  return {
+    Directive(directiveNode) {
+      const directiveName = directiveNode.name.value;
+      const knownArgs = directiveArgs[directiveName];
+
+      if (directiveNode.arguments && knownArgs) {
+        for (const argNode of directiveNode.arguments) {
+          const argName = argNode.name.value;
+          if (knownArgs.indexOf(argName) === -1) {
+            const suggestions = suggestionList(argName, knownArgs);
             context.reportError(
               new GraphQLError(
-                unknownDirectiveArgMessage(
-                  node.name.value,
-                  directive.name,
-                  suggestionList(
-                    node.name.value,
-                    directive.args.map(arg => arg.name),
-                  ),
-                ),
-                [node],
+                unknownDirectiveArgMessage(argName, directiveName, suggestions),
+                [argNode],
               ),
             );
           }
         }
       }
+
+      return false;
     },
   };
 }
diff --git a/src/validation/rules/KnownDirectives.js b/src/validation/rules/KnownDirectives.js
@@ -38,6 +38,7 @@ export function KnownDirectives(
   context: ValidationContext | SDLValidationContext,
 ): ASTVisitor {
   const locationsMap = Object.create(null);
+
   const schema = context.getSchema();
   const definedDirectives = schema
     ? schema.getDirectives()
diff --git a/src/validation/rules/ProvidedRequiredArguments.js b/src/validation/rules/ProvidedRequiredArguments.js
@@ -7,12 +7,17 @@
  * @flow strict
  */
 
-import type { ValidationContext } from '../ValidationContext';
+import type {
+  ValidationContext,
+  SDLValidationContext,
+} from '../ValidationContext';
 import { GraphQLError } from '../../error/GraphQLError';
+import { Kind } from '../../language/kinds';
 import inspect from '../../jsutils/inspect';
 import keyMap from '../../jsutils/keyMap';
 import { isRequiredArgument } from '../../type/definition';
 import type { ASTVisitor } from '../../language/visitor';
+import { specifiedDirectives } from '../../type/directives';
 
 export function missingFieldArgMessage(
   fieldName: string,
@@ -28,12 +33,13 @@ export function missingFieldArgMessage(
 export function missingDirectiveArgMessage(
   directiveName: string,
   argName: string,
-  type: string,
+  type?: ?string,
 ): string {
-  return (
-    `Directive "@${directiveName}" argument "${argName}" of type ` +
-    `"${type}" is required but not provided.`
-  );
+  let msg = `Directive "@${directiveName}" argument "${argName}"`;
+  if (type) {
+    msg += ' of type ' + type;
+  }
+  return msg + ' is required but not provided.';
 }
 
 /**
@@ -46,12 +52,13 @@ export function ProvidedRequiredArguments(
   context: ValidationContext,
 ): ASTVisitor {
   return {
+    ...ProvidedRequiredArgumentsOnDirectives(context),
     Field: {
       // Validate on leave to allow for deeper errors to appear first.
       leave(node) {
         const fieldDef = context.getFieldDef();
         if (!fieldDef) {
-          return false;
+          return;
         }
         const argNodes = node.arguments || [];
 
@@ -73,33 +80,69 @@ export function ProvidedRequiredArguments(
         }
       },
     },
+  };
+}
 
+// @internal
+export function ProvidedRequiredArgumentsOnDirectives(
+  context: ValidationContext | SDLValidationContext,
+): ASTVisitor {
+  const requiredArgsMap = Object.create(null);
+
+  const schema = context.getSchema();
+  const definedDirectives = schema
+    ? schema.getDirectives()
+    : specifiedDirectives;
+  for (const directive of definedDirectives) {
+    requiredArgsMap[directive.name] = directive.args
+      .filter(isRequiredArgument)
+      .map(arg => arg.name);
+  }
+
+  const astDefinitions = context.getDocument().definitions;
+  for (const def of astDefinitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      const args = def.arguments;
+      requiredArgsMap[def.name.value] = args
+        ? args.filter(isRequiredArgumentNode).map(arg => arg.name.value)
+        : [];
+    }
+  }
+
+  return {
     Directive: {
       // Validate on leave to allow for deeper errors to appear first.
       leave(node) {
-        const directiveDef = context.getDirective();
-        if (!directiveDef) {
-          return false;
-        }
-        const argNodes = node.arguments || [];
+        const directiveName = node.name.value;
+        const requiredArgs = requiredArgsMap[directiveName];
+        if (requiredArgs) {
+          const argNodes = node.arguments || [];
+          const argNodeMap = keyMap(argNodes, arg => arg.name.value);
+          for (const argName of requiredArgs) {
+            if (!argNodeMap[argName]) {
+              const directiveDef = schema && schema.getDirective(directiveName);
+              const argDef =
+                directiveDef &&
+                directiveDef.args.find(arg => arg.name === argName);
 
-        const argNodeMap = keyMap(argNodes, arg => arg.name.value);
-        for (const argDef of directiveDef.args) {
-          const argNode = argNodeMap[argDef.name];
-          if (!argNode && isRequiredArgument(argDef)) {
-            context.reportError(
-              new GraphQLError(
-                missingDirectiveArgMessage(
-                  node.name.value,
-                  argDef.name,
-                  inspect(argDef.type),
+              context.reportError(
+                new GraphQLError(
+                  missingDirectiveArgMessage(
+                    directiveName,
+                    argName,
+                    argDef && inspect(argDef.type),
+                  ),
+                  [node],
                 ),
-                [node],
-              ),
-            );
+              );
+            }
           }
         }
       },
     },
   };
 }
+
+function isRequiredArgumentNode(arg) {
+  return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;
+}
diff --git a/src/validation/specifiedRules.js b/src/validation/specifiedRules.js
@@ -123,12 +123,16 @@ export const specifiedRules: $ReadOnlyArray<ValidationRule> = [
 ];
 
 import { LoneSchemaDefinition } from './rules/LoneSchemaDefinition';
+import { KnownArgumentNamesOnDirectives } from './rules/KnownArgumentNames';
+import { ProvidedRequiredArgumentsOnDirectives } from './rules/ProvidedRequiredArguments';
 
 // @internal
 export const specifiedSDLRules: $ReadOnlyArray<SDLValidationRule> = [
   LoneSchemaDefinition,
   KnownDirectives,
   UniqueDirectivesPerLocation,
+  KnownArgumentNamesOnDirectives,
   UniqueArgumentNames,
   UniqueInputFieldNames,
+  ProvidedRequiredArgumentsOnDirectives,
 ];
