Validate directive arguments inside SDL

IvanGoncharov · IvanGoncharov · commit 1441d0e808e6 · 2018-08-20T16:41:15.000+03:00
diff --git a/src/validation/rules/KnownArgumentNames.js b/src/validation/rules/KnownArgumentNames.js
@@ -7,9 +7,14 @@
  * @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 { visitInParallel } from '../../language/visitor';
+import invariant from '../../jsutils/invariant';
 import suggestionList from '../../jsutils/suggestionList';
 import quotedOrList from '../../jsutils/quotedOrList';
 import { Kind } from '../../language/kinds';
@@ -48,47 +53,72 @@ export function unknownDirectiveArgMessage(
  * that field.
  */
 export function KnownArgumentNames(context: ValidationContext): ASTVisitor {
+  return visitInParallel([
+    KnownArgumentNamesOnDirectives(context),
+    {
+      Directive: () => false,
+      Argument(node) {
+        const argName = node.name.value;
+        const argDef = context.getArgument();
+        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();
+
+  if (schema) {
+    for (const directive of schema.getDirectives()) {
+      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) {
+      const name = def.name.value;
+      const args = def.arguments || [];
+      directiveArgs[name] = args.map(arg => arg.name.value);
+    }
+  }
+
   return {
     Argument(node, key, parent, path, ancestors) {
-      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) {
-            context.reportError(
-              new GraphQLError(
-                unknownDirectiveArgMessage(
-                  node.name.value,
-                  directive.name,
-                  suggestionList(
-                    node.name.value,
-                    directive.args.map(arg => arg.name),
-                  ),
-                ),
-                [node],
-              ),
-            );
-          }
+      const argumentOf = ancestors[ancestors.length - 1];
+      invariant(!Array.isArray(argumentOf));
+
+      if (argumentOf.kind === Kind.DIRECTIVE) {
+        const argName = node.name.value;
+        const directiveName = argumentOf.name.value;
+        const args = directiveArgs[directiveName];
+        if (args && args.indexOf(argName) === -1) {
+          const suggestions = suggestionList(argName, args);
+          context.reportError(
+            new GraphQLError(
+              unknownDirectiveArgMessage(argName, directiveName, suggestions),
+              [node],
+            ),
+          );
         }
       }
     },
diff --git a/src/validation/rules/ProvidedRequiredArguments.js b/src/validation/rules/ProvidedRequiredArguments.js
@@ -7,8 +7,12 @@
  * @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';
@@ -28,12 +32,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 +51,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,30 +79,61 @@ export function ProvidedRequiredArguments(
         }
       },
     },
+  };
+}
 
+// @internal
+export function ProvidedRequiredArgumentsOnDirectives(
+  context: ValidationContext | SDLValidationContext,
+): ASTVisitor {
+  const requiredArgsMap = Object.create(null);
+  const schema = context.getSchema();
+
+  if (schema) {
+    for (const directive of schema.getDirectives()) {
+      const requredArgs = directive.args.filter(isRequiredArgument);
+      requiredArgsMap[directive.name] = requredArgs.map(arg => arg.name);
+    }
+  }
+
+  const astDefinitions = context.getDocument().definitions;
+  for (const def of astDefinitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      const requredArgs = (def.arguments || []).filter(
+        arg => arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null,
+      );
+
+      requiredArgsMap[def.name.value] = requredArgs.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],
-              ),
-            );
+              );
+            }
           }
         }
       },
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,
 ];
