GraphQL\Validator\Rules\ProvidedRequiredArgumentsOnDirectives

Complexity

Total Complexity

16

Size/Duplication

Total Lines	79
Duplicated Lines	0 %

Test Coverage

Coverage

65.22%

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
C	getSDLVisitor()	0	72	15
A	missingDirectiveArgMessage()	0	3	1

<?php

declare(strict_types=1);

namespace GraphQL\Validator\Rules;

use GraphQL\Error\Error;
use GraphQL\Language\AST\ArgumentNode;
use GraphQL\Language\AST\DirectiveDefinitionNode;
use GraphQL\Language\AST\DirectiveNode;
use GraphQL\Language\AST\NamedTypeNode;
use GraphQL\Language\AST\Node;
use GraphQL\Language\AST\NodeKind;
use GraphQL\Language\AST\NodeList;
use GraphQL\Language\AST\NonNullTypeNode;
use GraphQL\Type\Definition\Directive;
use GraphQL\Type\Definition\FieldArgument;
use GraphQL\Type\Definition\NonNull;
use GraphQL\Utils\Utils;
use GraphQL\Validator\SDLValidationContext;
use function array_filter;
use function is_array;
use function iterator_to_array;

/**
 * Provided required arguments on directives
 *
 * A directive is only valid if all required (non-null without a
 * default value) field arguments have been provided.
 */
class ProvidedRequiredArgumentsOnDirectives extends ValidationRule
{
    protected static function missingDirectiveArgMessage(string $directiveName, string $argName)
    {
        return 'Directive "' . $directiveName . '" argument "' . $argName . '" is required but ont provided.';
    }

    public function getSDLVisitor(SDLValidationContext $context)
    {
        $requiredArgsMap   = [];
        $schema            = $context->getSchema();
        $definedDirectives = $schema

$schema is of type GraphQL\Type\Schema, thus it always evaluated to true.

            ? $schema->getDirectives()
            : Directive::getInternalDirectives();

        foreach ($definedDirectives as $directive) {
            $requiredArgsMap[$directive->name] = Utils::keyMap(
                array_filter($directive->args, static function (FieldArgument $arg) : bool {
                    return $arg->getType() instanceof NonNull && ! isset($arg->defaultValue);
                }),
                static function (FieldArgument $arg) : string {
                    return $arg->name;
                }
            );
        }

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

            if (is_array($def->arguments)) {
                $arguments = $def->arguments;
            } elseif ($def->arguments instanceof NodeList) {
                $arguments = iterator_to_array($def->arguments->getIterator());
            } else {
                $arguments = null;
            }

            $requiredArgsMap[$def->name->value] = Utils::keyMap(
                $arguments
                    ? array_filter($arguments, static function (Node $argument) : bool {
                        return $argument instanceof NonNullTypeNode &&
                            (
                                ! isset($argument->defaultValue) ||
                                $argument->defaultValue === null
                            );
                    })
                    : [],
                static function (NamedTypeNode $argument) : string {
                    return $argument->name->value;
                }
            );
        }

        return [
            NodeKind::DIRECTIVE => static function (DirectiveNode $directiveNode) use ($requiredArgsMap, $context) {
                $directiveName = $directiveNode->name->value;
                $requiredArgs  = $requiredArgsMap[$directiveName] ?? null;
                if (! $requiredArgs) {
                    return null;
                }

                $argNodes   = $directiveNode->arguments ?: [];
                $argNodeMap = Utils::keyMap(
                    $argNodes,
                    static function (ArgumentNode $arg) : string {
                        return $arg->name->value;
                    }
                );

                foreach ($requiredArgs as $argName => $arg) {
                    if (isset($argNodeMap[$argName])) {
                        continue;
                    }

                    $context->reportError(
                        new Error(static::missingDirectiveArgMessage($directiveName, $argName), [$directiveNode])
                    );
                }
            },
        ];
    }
}