FRZB\Component\RequestMapper\Extractor\ConstraintExtractor

Complexity

Total Complexity

9

Size/Duplication

Total Lines	57
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getPropertyMetadataFor()	0	3	2
A	__construct()	0	3	1
A	getClassMetadataFor()	0	3	1
A	extract()	0	6	2
A	getPropertyReflectionMember()	0	3	1
A	extractConstraints()	0	23	2

<?php

declare(strict_types=1);

namespace FRZB\Component\RequestMapper\Extractor;

use Fp\Collections\ArrayList;
use FRZB\Component\DependencyInjection\Attribute\AsService;
use FRZB\Component\RequestMapper\Helper\ClassHelper;
use FRZB\Component\RequestMapper\Helper\ConstraintsHelper;
use FRZB\Component\RequestMapper\Helper\SerializerHelper;
use Symfony\Component\Validator\Constraints\All;
use Symfony\Component\Validator\Constraints\Collection;
use Symfony\Component\Validator\Exception\NoSuchMetadataException;
use Symfony\Component\Validator\Mapping\ClassMetadata as ClassMetadataImpl;
use Symfony\Component\Validator\Mapping\ClassMetadataInterface as ClassMetadata;
use Symfony\Component\Validator\Mapping\Factory\MetadataFactoryInterface as MetadataFactory;
use Symfony\Component\Validator\Mapping\PropertyMetadata as PropertyMetadataImpl;
use Symfony\Component\Validator\Mapping\PropertyMetadataInterface as PropertyMetadata;
use Symfony\Component\Validator\Validator\ValidatorInterface as Validator;

#[AsService(arguments: ['$metadataFactory' => Validator::class])]
class ConstraintExtractor
{
    public function __construct(
        private readonly MetadataFactory $metadataFactory,
    ) {
    }

    public function extract(string $class, array $parameters = []): ?Collection
    {
        try {
            return ConstraintsHelper::createCollection($this->extractConstraints($class, $parameters));
        } catch (NoSuchMetadataException|\ReflectionException) {
            return null;
        }
    }

    /** @throws NoSuchMetadataException|\ReflectionException */
    public function extractConstraints(string $class, array $parameters = []): array
    {
        $constraints = [];
        $classMetadata = $this->getClassMetadataFor($class);
        $reflectionClass = new \ReflectionClass($class);

        foreach ($reflectionClass->getProperties() as $property) {
            $propertyName = $property->getName();
            $propertyMetadata = $this->getPropertyMetadataFor($classMetadata, $propertyName);
            $propertyReflectionMember = $this->getPropertyReflectionMember($class, $propertyMetadata);
            $propertySerializedName = SerializerHelper::getSerializedNameAttribute($propertyReflectionMember)?->getSerializedName();

It seems like $propertyReflectionMember can also be of type ReflectionMethod; however, parameter $rProperty of FRZB\Component\RequestMapper\Helper\SerializerHelper::getSerializedNameAttribute() does only seem to accept ReflectionProperty, maybe add an additional type check?

            $propertyTypeName = $propertyReflectionMember->getType()?->getName();

The method getType() does not exist on ReflectionMethod.

The method getName() does not exist on ReflectionType. It seems like you code against a sub-type of ReflectionType such as ReflectionNamedType.

            $propertyValue = $parameters[$propertySerializedName] ?? $parameters[$propertyName] ?? [];
            $arrayTypeName = ConstraintsHelper::getArrayTypeAttribute($propertyReflectionMember)?->typeName;

It seems like $propertyReflectionMember can also be of type ReflectionMethod; however, parameter $rProperty of FRZB\Component\RequestMapper\Helper\ConstraintsHelper::getArrayTypeAttribute() does only seem to accept ReflectionProperty, maybe add an additional type check?

            $constraints[$propertySerializedName] = match (true) {
                ConstraintsHelper::hasArrayTypeAttribute($propertyReflectionMember) => ArrayList::collect($propertyValue)->map(fn () => new All($this->extract($arrayTypeName, $propertyValue)))->toArray(),

It seems like $propertyReflectionMember can also be of type ReflectionMethod; however, parameter $rProperty of FRZB\Component\RequestMapper\Helper\ConstraintsHelper::hasArrayTypeAttribute() does only seem to accept ReflectionProperty, maybe add an additional type check?

                ClassHelper::isNotBuiltinAndExists($propertyTypeName) => $this->extract($propertyTypeName),
                default => $propertyMetadata->getConstraints(),
            };
        }

        return $constraints;
    }

    /** @noinspection PhpIncompatibleReturnTypeInspection */
    private function getClassMetadataFor(string $class): ClassMetadata
    {
        return $this->metadataFactory->getMetadataFor($class) ?? new ClassMetadataImpl($class);

The expression return $this->metadataFactory->getMetadataFor($class) ?? new Symfony\Component\Validator\Mapping\ClassMetadata($class) could return the type Symfony\Component\Validator\Mapping\MetadataInterface which includes types incompatible with the type-hinted return Symfony\Component\Validator\Mapping\ClassMetadataInterface. Consider adding an additional type-check to rule them out.

    }

    private function getPropertyMetadataFor(ClassMetadata $classMetadata, string $propertyName): PropertyMetadata
    {
        return current($classMetadata->getPropertyMetadata($propertyName)) ?: new PropertyMetadataImpl($classMetadata->getClassName(), $propertyName);
    }

    private function getPropertyReflectionMember(string $class, PropertyMetadata $propertyMetadata): \ReflectionMethod|\ReflectionProperty
    {
        return $propertyMetadata->getReflectionMember($class);
    }
}