Digia\GraphQL\Execution\ValuesResolver::coerceArgumentValues()

Complexity

Conditions	21
Paths	110

Size

Total Lines	114
Code Lines	72

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

<?php
    public static function coerceArgumentValues(
        $definition,
        ArgumentsAwareInterface $node,
        array $variableValues = []
    ): array {
        $coercedValues       = [];
        $argumentDefinitions = $definition->getArguments();
        $argumentNodes       = $node->getArguments();

        if (empty($argumentDefinitions)) {
            return $coercedValues;
        }

        /** @var ArgumentNode[] $argumentNodeMap */
        $argumentNodeMap = keyMap($argumentNodes, function (ArgumentNode $value) {
            return $value->getNameValue();
        });

        foreach ($argumentDefinitions as $argumentDefinition) {
            $argumentName  = $argumentDefinition->getName();
            $argumentType  = $argumentDefinition->getType();
            $argumentNode  = $argumentNodeMap[$argumentName] ?? null;
            $defaultValue  = $argumentDefinition->getDefaultValue();
            $argumentValue = null !== $argumentNode ? $argumentNode->getValue() : null;

            if (null !== $argumentNode && $argumentValue instanceof VariableNode) {
                $variableName = $argumentValue->getNameValue();
                $hasValue     = !empty($variableValues) && \array_key_exists($variableName, $variableValues);
                $isNull       = $hasValue && null === $variableValues[$variableName];
            } else {
                $hasValue = null !== $argumentNode;
                $isNull   = $hasValue && $argumentValue instanceof NullValueNode;
            }

            if (!$hasValue && null !== $defaultValue) {
                // If no argument was provided where the definition has a default value,
                // use the default value.
                $coercedValues[$argumentName] = $defaultValue;
            } elseif ((!$hasValue || $isNull) && $argumentType instanceof NonNullType) {
                // If no argument or a null value was provided to an argument with a
                // non-null type (required), produce a field error.
                if ($isNull) {
                    throw new ExecutionException(
                        \sprintf(
                            'Argument "%s" of non-null type "%s" must not be null.',
                            $argumentName,
                            $argumentType
                        ),
                        [$argumentValue]
                    );
                } elseif (null !== $argumentNode && $argumentValue instanceof VariableNode) {
                    $variableName = $argumentValue->getNameValue();
                    throw new ExecutionException(
                        \sprintf(
                            'Argument "%s" of required type "%s" was provided the variable "$%s" '
                            . 'which was not provided a runtime value.',
                            $argumentName,
                            $argumentType,
                            $variableName
                        ),
                        [$argumentValue]
                    );
                } else {
                    throw new ExecutionException(
                        \sprintf(
                            'Argument "%s" of required type "%s" was not provided.',
                            $argumentName,
                            $argumentType
                        ),
                        [$node]
                    );
                }
            } elseif ($hasValue) {
                if ($argumentValue instanceof NullValueNode) {
                    // If the explicit value `null` was provided, an entry in the coerced
                    // values must exist as the value `null`.
                    $coercedValues[$argumentName] = null;
                } elseif ($argumentValue instanceof VariableNode) {
                    $variableName = $argumentValue->getNameValue();
                    invariant(!empty($variableValues), 'Must exist for hasValue to be true.');
                    // Note: This does no further checking that this variable is correct.
                    // This assumes that this query has been validated and the variable
                    // usage here is of the correct type.
                    $coercedValues[$argumentName] = $variableValues[$variableName];
                } else {
                    $valueNode = $argumentNode->getValue();

The method getValue() does not exist on null.

                    try {
                        // Value nodes that cannot be resolved should be treated as invalid values
                        // because there is no undefined value in PHP so that we throw an exception
                        $coercedValue = ValueASTConverter::convert($valueNode, $argumentType, $variableValues);

It seems like $argumentType can also be of type null; however, parameter $type of Digia\GraphQL\Util\ValueASTConverter::convert() does only seem to accept Digia\GraphQL\Type\Definition\TypeInterface, maybe add an additional type check?

It seems like $valueNode can also be of type null; however, parameter $node of Digia\GraphQL\Util\ValueASTConverter::convert() does only seem to accept Digia\GraphQL\Language\Node\NodeInterface, maybe add an additional type check?

                    } catch (\Exception $ex) {
                        // Note: ValuesOfCorrectType validation should catch this before
                        // execution. This is a runtime check to ensure execution does not
                        // continue with an invalid argument value.
                        throw new ExecutionException(
                            \sprintf(
                                'Argument "%s" has invalid value %s.',
                                $argumentName,
                                (string)$argumentValue
                            ),
                            [$argumentValue],
                            null,
                            null,
                            null,
                            null,
                            $ex
                        );
                    }
                    $coercedValues[$argumentName] = $coercedValue;
                }
            }
        }

        return $coercedValues;
    }