FRZB\Component\RequestMapper\Converter\RequestConverter

Complexity

Total Complexity

9

Size/Duplication

Total Lines	49
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	validate()	0	4	2
A	convert()	0	27	6

<?php

declare(strict_types=1);

namespace FRZB\Component\RequestMapper\Converter;

use FRZB\Component\DependencyInjection\Attribute\AsService;
use FRZB\Component\RequestMapper\Data\ConverterData;
use FRZB\Component\RequestMapper\Data\ValidationError;
use FRZB\Component\RequestMapper\Exception\ClassExtractorException;
use FRZB\Component\RequestMapper\Exception\ConverterException;
use FRZB\Component\RequestMapper\Exception\ValidationException;
use FRZB\Component\RequestMapper\Extractor\ConstraintExtractor;
use FRZB\Component\RequestMapper\Extractor\DiscriminatorMapExtractor;
use FRZB\Component\RequestMapper\Extractor\ParametersExtractor;
use FRZB\Component\RequestMapper\Parser\ExceptionConverterInterface as ExceptionConverter;
use Symfony\Component\Serializer\Annotation\DiscriminatorMap;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface as Denormalizer;
use Symfony\Component\Validator\Constraints\Collection;
use Symfony\Component\Validator\Validator\ValidatorInterface as Validator;

#[AsService]
class RequestConverter implements ConverterInterface
{
    private const DENORMALIZE_TYPE = 'array';

    public function __construct(
        private Validator $validator,
        private Denormalizer $denormalizer,
        private ExceptionConverter $exceptionConverter,
        private DiscriminatorMapExtractor $classExtractor,
        private ConstraintExtractor $constraintExtractor,
        private ParametersExtractor $parametersExtractor,
    ) {
    }

    public function convert(ConverterData $data): object
    {
        try {
            $parameters = $data->getRequest()->request->all();
            $class = $this->classExtractor->extract($data->getParameterClass(), $parameters);

It seems like $data->getParameterClass() can also be of type null; however, parameter $class of FRZB\Component\RequestMapper\Extractor\DiscriminatorMapExtractor::extract() does only seem to accept string, maybe add an additional type check?

        } catch (ClassExtractorException $e) {
            throw ValidationException::fromErrors(ValidationError::fromTypeAndClassExtractorException(DiscriminatorMap::class, $e));
        } catch (\Throwable $e) {
            throw ConverterException::fromThrowable($e);
        }

        if ($data->isValidationNeeded()) {
            $constraints = $this->constraintExtractor->extract($class);
            $parameters = $this->parametersExtractor->extract($data->getParameterClass(), $parameters);

It seems like $data->getParameterClass() can also be of type null; however, parameter $class of FRZB\Component\RequestMapper\Extractor\ParametersExtractor::extract() does only seem to accept string, maybe add an additional type check?

            $this->validate($parameters, $data->getValidationGroups(), $constraints);
        }

        try {
            $object = $this->denormalizer->denormalize($parameters, $class, self::DENORMALIZE_TYPE, $data->getSerializerContext());
        } catch (\TypeError $e) {
            throw ValidationException::fromErrors($this->exceptionConverter->convert($e, $parameters));
        } catch (\Throwable $e) {
            throw ConverterException::fromThrowable($e);
        }

        return $object;
    }

    /** @throws ValidationException */
    private function validate(mixed $target, array $validationGroups, ?Collection $constraints = null): void
    {
        if (($violations = $this->validator->validate($target, $constraints, $validationGroups))->count()) {
            throw ValidationException::fromConstraintViolationList($violations);
        }
    }
}