ValidatorResolver.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Extbase\Validation;
 
use Symfony\Component\PropertyInfo\Type;
use ‪TYPO3\CMS\Core\Log\LogManager;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Reflection\ReflectionService;
use ‪TYPO3\CMS\Extbase\Utility\TypeHandlingUtility;
use ‪TYPO3\CMS\Extbase\Validation\Exception\NoSuchValidatorException;
use ‪TYPO3\CMS\Extbase\Validation\Validator\CollectionValidator;
use ‪TYPO3\CMS\Extbase\Validation\Validator\ConjunctionValidator;
use ‪TYPO3\CMS\Extbase\Validation\Validator\GenericObjectValidator;
use ‪TYPO3\CMS\Extbase\Validation\Validator\ValidatorInterface;
 
class ‪ValidatorResolver implements ‪SingletonInterface
{
    protected array ‪$baseValidatorConjunctions = [];
 
    public function ‪__construct(protected readonly ‪ReflectionService $reflectionService) {}
 
    public function ‪createValidator(string $validatorType, array $validatorOptions = []): ?‪ValidatorInterface
    {
        try {
            $validatorObjectName = ‪ValidatorClassNameResolver::resolve($validatorType);
            ‪$validator = GeneralUtility::makeInstance($validatorObjectName);
            ‪$validator->setOptions($validatorOptions);
            return ‪$validator;
        } catch (‪NoSuchValidatorException $e) {
            GeneralUtility::makeInstance(LogManager::class)->getLogger(__CLASS__)->debug($e->getMessage());
            return null;
        }
    }
 
    public function ‪getBaseValidatorConjunction(string $targetClassName): ‪ConjunctionValidator
    {
        if (!isset($this->baseValidatorConjunctions[$targetClassName])) {
            $conjunctionValidator = GeneralUtility::makeInstance(ConjunctionValidator::class);
            $this->baseValidatorConjunctions[$targetClassName] = $conjunctionValidator;
            // The simpleType check reduces lookups to the class loader
            if (!‪TypeHandlingUtility::isSimpleType($targetClassName) && class_exists($targetClassName)) {
                $this->‪buildBaseValidatorConjunction($conjunctionValidator, $targetClassName);
            }
        }
        return $this->baseValidatorConjunctions[$targetClassName];
    }
 
    protected function ‪buildBaseValidatorConjunction(‪ConjunctionValidator $conjunctionValidator, string $targetClassName): void
    {
        $classSchema = $this->reflectionService->getClassSchema($targetClassName);
 
        // Model based validator
        $objectValidator = $this->‪createValidator(GenericObjectValidator::class);
        foreach ($classSchema->getProperties() as $property) {
            $primaryType = $property->getPrimaryType();
            if (!$primaryType instanceof Type) {
                // @todo: The type is only necessary here for further analyzing whether it's a simple type or
                //        a collection. If this is evaluated in the ClassSchema, this whole code part is not needed
                //        any longer and can be removed.
                throw new \InvalidArgumentException(
                    sprintf('There is no @var annotation or type declaration for property "%s" in class "%s".', $property->getName(), $targetClassName),
                    1363778104
                );
            }
 
            $propertyTargetClassName = $primaryType->getClassName() ?? $primaryType->getBuiltinType();
 
            if (!‪TypeHandlingUtility::isSimpleType($propertyTargetClassName)) {
                // The outer simpleType check reduces lookups to the class loader
                // @todo: Whether the property holds a simple type or not and whether it holds a collection is known in
                //        in the ClassSchema. The information could be made available and not evaluated here again.
                $primaryCollectionValueType = $property->getPrimaryCollectionValueType();
                if ($primaryType->isCollection() && $primaryCollectionValueType instanceof Type) {
                    $collectionValidator = $this->‪createValidator(
                        CollectionValidator::class,
                        [
                            'elementType' => $primaryCollectionValueType->getClassName() ?? $primaryCollectionValueType->getBuiltinType(),
                        ]
                    );
                    $objectValidator->addPropertyValidator($property->getName(), $collectionValidator);
                } elseif (class_exists($propertyTargetClassName)
                    && !‪TypeHandlingUtility::isCoreType($propertyTargetClassName)
                    && !in_array(SingletonInterface::class, class_implements($propertyTargetClassName) ?: [], true)
                ) {
                    // class_exists($propertyTargetClassName) checks, if the type of the property is an object
                    // instead of a simple type. Like DateTime or another model.
                    //
                    // !TypeHandlingUtility::isCoreType($propertyTargetClassName) checks if the type of the property
                    // is not a core type, which are Enums and File objects for example.
                    // @todo: check why these types shouldn't be validated.
                    //
                    // !in_array(SingletonInterface::class, class_implements($propertyTargetClassName, true), true)
                    // checks if the class is an instance of a Singleton
                    // @todo: check why Singletons shouldn't be validated.
                    //
                    // (Alexander Schnitzler) By looking at this code I assume that this is the path for 1:1
                    // relations in models. Still, the question remains why it excludes core types and singletons.
                    // It makes sense on a theoretical level, but I don't see a technical issue allowing these as
                    // well.
                    $validatorForProperty = $this->‪getBaseValidatorConjunction($propertyTargetClassName);
                    if ($validatorForProperty->count() > 0) {
                        $objectValidator->addPropertyValidator($property->getName(), $validatorForProperty);
                    }
                }
            }
 
            foreach ($property->getValidators() as $validatorDefinition) {
                // @todo: At this point we already have the class name of the validator, thus there is not need
                //        calling ValidatorClassNameResolver::resolve inside
                //        \TYPO3\CMS\Extbase\Validation\ValidatorResolver::createValidator once again. However, to
                //        keep things simple for now, we still use the method createValidator here. In the future,
                //        createValidator must only accept FQCN's.
                $newValidator = $this->‪createValidator($validatorDefinition['className'], $validatorDefinition['options']);
                if ($newValidator === null) {
                    throw new ‪NoSuchValidatorException(
                        'Invalid validate annotation in ' . $targetClassName . '::' . $property->getName() . ': ' .
                        'Could not resolve class name for validator "' . $validatorDefinition['className'] . '".',
                        1241098027
                    );
                }
                $objectValidator->addPropertyValidator($property->getName(), $newValidator);
            }
        }
 
        if (!empty($objectValidator->getPropertyValidators())) {
            $conjunctionValidator->‪addValidator($objectValidator);
        }
    }
}