Yiisoft\RequestModel\RequestModelFactory

Complexity

Total Complexity

14

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	createInstances()	0	8	2
A	processModel()	0	13	3
A	__construct()	0	5	1
A	getRequestData()	0	10	1
A	getModelRequestClasses()	0	21	5
A	isInstantiableRequestModel()	0	6	2

<?php

declare(strict_types=1);

namespace Yiisoft\RequestModel;

use Psr\Http\Message\ServerRequestInterface;
use ReflectionClass;
use ReflectionException;
use ReflectionNamedType;
use ReflectionParameter;
use Yiisoft\Injector\Injector;
use Yiisoft\Router\CurrentRoute;
use Yiisoft\Validator\RulesProviderInterface;
use Yiisoft\Validator\ValidatorInterface;

final class RequestModelFactory
{
    public function __construct(
        private ValidatorInterface $validator,
        private Injector $injector,
        private CurrentRoute $currentRoute
    ) {
    }

    /**
     * @param ReflectionParameter[] $handlerParams
     *
     * @throws ReflectionException
     */
    public function createInstances(ServerRequestInterface $request, array $handlerParams): array
    {
        $requestModelInstances = [];
        foreach ($this->getModelRequestClasses($handlerParams) as $modelClass) {
            $requestModelInstances[] = $this->processModel($request, $this->injector->make($modelClass));
        }

        return $requestModelInstances;
    }

    private function processModel(ServerRequestInterface $request, RequestModelInterface $model): RequestModelInterface
    {
        $requestData = $this->getRequestData($request);
        $model->setRequestData($requestData);
        if ($model instanceof RulesProviderInterface) {
            $result = $this->validator->validate($model);
            if (!$result->isValid()) {
                $errorMessagesIndexedByAttribute = $result->getErrorMessagesIndexedByAttribute();
                throw new RequestValidationException($errorMessagesIndexedByAttribute);
            }
        }

        return $model;
    }

    /**
     * @param ReflectionParameter[] $handlerParams
     *
     * @psalm-return list<class-string<RequestModelInterface>>
     */
    private function getModelRequestClasses(array $handlerParams): array
    {
        $modelClasses = [];
        foreach ($handlerParams as $param) {
            $type = $param->getType();
            if (
                !$type instanceof ReflectionNamedType
                || $type->isBuiltin()
            ) {
                continue;
            }

            $className = $type->getName();
            if (!$this->isInstantiableRequestModel($className)) {
                continue;
            }

            $modelClasses[] = $className;
        }

        return $modelClasses;
    }

    /**
     * @psalm-param class-string $className
     * @psalm-assert-if-true class-string<RequestModelInterface> $className
     */
    private function isInstantiableRequestModel(string $className): bool
    {
        $reflectionClass = new ReflectionClass($className);

        return $reflectionClass->isInstantiable()
            && $reflectionClass->implementsInterface(RequestModelInterface::class);
    }

    private function getRequestData(ServerRequestInterface $request): array
    {
        return [
            'query' => $request->getQueryParams(),
            'body' => $request->getParsedBody(),
            'attributes' => $request->getAttributes(),
            'headers' => $request->getHeaders(),
            'files' => $request->getUploadedFiles(),
            'cookie' => $request->getCookieParams(),
            'router' => $this->currentRoute->getArguments(),
        ];
    }
}