valueFromAST()

Complexity

Conditions	28
Paths	27

Size

Total Lines	137
Code Lines	69

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
function valueFromAST(?ValueNodeInterface $node, TypeInterface $type, array $variables = [])
{
    // TODO: Refactor this method, maybe into a more OOP approach.

    if (null === $node) {
        return; // Invalid: intentionally return no value.
    }

    if ($type instanceof NonNullType) {
        if ($node instanceof NullValueNode) {
            return; // Invalid: intentionally return no value.
        }

        return valueFromAST($node, $type->getOfType(), $variables);
    }

    if ($node instanceof NullValueNode) {
        return null;
    }

    if ($node instanceof VariableNode) {
        $variableName = $node->getNameValue();

        if (!isset($variables[$variableName])) {
            // No valid return value.
            return;
        }

        // Note: we're not doing any checking that this variable is correct. We're
        // assuming that this query has been validated and the variable usage here
        // is of the correct type.
        return $variables[$variableName];
    }

    if ($type instanceof ListType) {
        $itemType = $type->getOfType();

        if ($node instanceof ListValueNode) {
            $coercedValues = [];

            foreach ($node->getValues() as $value) {
                if (isMissingVariable($value, $variables)) {
                    // If an array contains a missing variable, it is either coerced to
                    // null or if the item type is non-null, it considered invalid.
                    if ($itemType instanceof NonNullType) {
                        return; // Invalid: intentionally return no value.
                    }
                    $coercedValues[] = null;
                } else {
                    $itemValue = valueFromAST($value, $itemType, $variables);
                    if (!$itemValue) {
                        return; // Invalid: intentionally return no value.
                    }
                    $coercedValues[] = $itemValue;
                }
            }

            return $coercedValues;
        }

        $coercedValue = valueFromAST($node, $itemType, $variables);
        if (!$coercedValue) {
            return; // Invalid: intentionally return no value.
        }
        return [$coercedValue];
    }

    if ($type instanceof InputObjectType) {
        if (!$node instanceof ObjectValueNode) {
            return; // Invalid: intentionally return no value.
        }

        $coercedObject = [];

        /** @var ObjectFieldNode[] $fieldNodes */
        $fieldNodes = keyMap($node->getFields(), function (FieldNode $value) {
            return $value->getNameValue();
        });

        foreach ($type->getFields() as $field) {
            $name      = $field->getName();
            $fieldNode = $fieldNodes[$name];

            if (null === $fieldNode || isMissingVariable($fieldNode->getValue(), $variables)) {
                if (null !== $field->getDefaultValue()) {
                    $coercedObject[$name] = $field->getDefaultValue();
                } elseif ($field->getType() instanceof NonNullType) {
                    return; // Invalid: intentionally return no value.
                }
                continue;
            }

            $fieldValue = valueFromAST($fieldNode->getValue(), $field->getType(), $variables);

            if (!$fieldValue) {
                return; // Invalid: intentionally return no value.
            }

            $coercedObject[$name] = $fieldValue;
        }

        return $coercedObject;
    }

    if ($type instanceof EnumType) {
        if (!$node instanceof EnumValueNode) {
            return; // Invalid: intentionally return no value.
        }

        $enumValue = $type->getValue($node->getValue());

        if (null === $enumValue) {
            return; // Invalid: intentionally return no value.
        }

        return $enumValue->getValue();
    }

    if ($type instanceof ScalarType) {
        // Scalars fulfill parsing a literal value via parseLiteral().
        // Invalid values represent a failure to parse correctly, in which case
        // no value is returned.
        $result = null;

The assignment to $result is dead and can be removed.

        try {
            $result = $type->parseLiteral($node, $variables);

$node of type Digia\GraphQL\Language\Node\ValueNodeInterface is incompatible with the type array expected by parameter $args of Digia\GraphQL\Type\Definition\ScalarType::parseLiteral().

        } catch (\Exception $e) {
            return; // Invalid: intentionally return no value.
        }

        if (null === $result) {
            return; // Invalid: intentionally return no value.
        }

        return $result;
    }

    throw new InvalidTypeException(sprintf('Unknown type: %s', $type));

$type of type Digia\GraphQL\Type\Definition\TypeInterface is incompatible with the type string expected by parameter $args of sprintf().

}