GraphQL\Validator\Rules\KnownArgumentNamesOnDirectives

Complexity

Total Complexity

12

Size/Duplication

Total Lines	62
Duplicated Lines	0 %

Test Coverage

Coverage

85.29%

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	unknownDirectiveArgMessage()	0	3	1
B	getSDLVisitor()	0	55	11

<?php

declare(strict_types=1);

namespace GraphQL\Validator\Rules;

use GraphQL\Error\Error;
use GraphQL\Language\AST\DirectiveDefinitionNode;
use GraphQL\Language\AST\DirectiveNode;
use GraphQL\Language\AST\InputValueDefinitionNode;
use GraphQL\Language\AST\NodeKind;
use GraphQL\Language\AST\NodeList;
use GraphQL\Type\Definition\Directive;
use GraphQL\Type\Definition\FieldArgument;
use GraphQL\Validator\SDLValidationContext;
use function array_map;
use function in_array;
use function iterator_to_array;

/**
 * Known argument names on directives
 *
 * A GraphQL directive is only valid if all supplied arguments are defined by
 * that field.
 */
class KnownArgumentNamesOnDirectives extends ValidationRule
{
    protected static function unknownDirectiveArgMessage(string $argName, string $directionName)
    {
        return 'Unknown argument "' . $argName . '" on directive "@' . $directionName . '".';
    }

    public function getSDLVisitor(SDLValidationContext $context)
    {
        $directiveArgs     = [];
        $schema            = $context->getSchema();
        $definedDirectives = $schema !== null ? $schema->getDirectives() : Directive::getInternalDirectives();

        foreach ($definedDirectives as $directive) {
            $directiveArgs[$directive->name] = array_map(
                static function (FieldArgument $arg) : string {
                    return $arg->name;
                },
                $directive->args
            );
        }

        $astDefinitions = $context->getDocument()->definitions;
        foreach ($astDefinitions as $def) {
            if (! ($def instanceof DirectiveDefinitionNode)) {
                continue;
            }

            $name = $def->name->value;
            if ($def->arguments !== null) {
                $arguments = $def->arguments;

                if ($arguments instanceof NodeList) {
                    $arguments = iterator_to_array($arguments->getIterator());
                }

                $directiveArgs[$name] = array_map(static function (InputValueDefinitionNode $arg) : string {
                    return $arg->name->value;
                }, $arguments);
            } else {
                $directiveArgs[$name] = [];
            }
        }

        return [
            NodeKind::DIRECTIVE => static function (DirectiveNode $directiveNode) use ($directiveArgs, $context) {
                $directiveName = $directiveNode->name->value;
                $knownArgs     = $directiveArgs[$directiveName] ?? null;

                if ($directiveNode->arguments === null || ! $knownArgs) {
                    return;
                }

                foreach ($directiveNode->arguments as $argNode) {
                    $argName = $argNode->name->value;
                    if (in_array($argName, $knownArgs, true)) {
                        continue;
                    }

                    $context->reportError(new Error(
                        self::unknownDirectiveArgMessage($argName, $directiveName),
                        [$argNode]
                    ));
                }
            },
        ];
    }
}