Ecodev\Felix\Api\Scalar\AbstractDecimalType

Complexity

Total Complexity

16

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Test Coverage

Coverage

86.21%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	parseValue()	0	8	2
A	parseLiteral()	0	15	5
A	getMinimum()	0	3	1
A	getMaximum()	0	3	1
A	serialize()	0	4	1
A	isValid()	0	19	6

<?php

declare(strict_types=1);

namespace Ecodev\Felix\Api\Scalar;

use GraphQL\Error\Error;
use GraphQL\Language\AST\FloatValueNode;
use GraphQL\Language\AST\IntValueNode;
use GraphQL\Language\AST\Node;
use GraphQL\Language\AST\StringValueNode;
use GraphQL\Type\Definition\ScalarType;
use GraphQL\Utils\Utils;

abstract class AbstractDecimalType extends ScalarType
{
    /**
     * Return the number of digits after the decimal.
     */
    abstract protected function getScale(): int;

    /**
     * Return the minimum accepted value, if any.
     */
    protected function getMinimum(): ?string
    {
        return null;
    }

    /**
     * Return the maximum accepted value, if any.
     */
    protected function getMaximum(): ?string
    {
        return null;
    }

    /**
     * Validate value.
     */
    private function isValid(string $value): bool
    {
        $decimal = $this->getScale();

        if (!preg_match('~^-?\d+(\.\d{0,' . $decimal . '})?$~', $value)) {
            return false;
        }

        $minimum = $this->getMinimum();

Are you sure the assignment to $minimum is correct as $this->getMinimum() targeting Ecodev\Felix\Api\Scalar\AbstractDecimalType::getMinimum() seems to always return null.

        if ($minimum !== null && bccomp($value, $minimum, $decimal) === -1) {

The condition $minimum !== null is always false.

            return false;
        }

        $maximum = $this->getMaximum();

Are you sure the assignment to $maximum is correct as $this->getMaximum() targeting Ecodev\Felix\Api\Scalar\AbstractDecimalType::getMaximum() seems to always return null.

        if ($maximum !== null && bccomp($value, $maximum, $decimal) === 1) {

The condition $maximum !== null is always false.

            return false;
        }

        return true;
    }

    /**
     * Serializes an internal value to include in a response.
     */
    public function serialize(mixed $value): mixed
    {
        // Assuming internal representation is always correct:
        return $value;
    }

    /**
     * Parses an externally provided value (query variable) to use as an input.
     *
     * @param null|float|int|string $value
     */
    public function parseValue(mixed $value): string
    {
        $parsedValue = (string) $value;
        if (!$this->isValid($parsedValue)) {
            throw new Error('Query error: Not a valid ' . $this->name . ': ' . Utils::printSafe($value));
        }

        return $parsedValue;
    }

    /**
     * Parses an externally provided literal value to use as an input (e.g. in Query AST).
     */
    public function parseLiteral(Node $valueNode, ?array $variables = null): string
    {
        // Note: throwing GraphQL\Error\Error vs \UnexpectedValueException to benefit from GraphQL
        // error location in query:

        if (!($valueNode instanceof StringValueNode || $valueNode instanceof IntValueNode || $valueNode instanceof FloatValueNode)) {
            throw new Error('Query error: Can only parse strings got: ' . $valueNode->kind, $valueNode);
        }

        $parsedValue = (string) $valueNode->value;
        if (!$this->isValid($parsedValue)) {
            throw new Error('Query error: Not a valid ' . $this->name, $valueNode);
        }

        return $parsedValue;
    }
}