Yiisoft\RequestModel\RequestModelFactory

Complexity

Total Complexity

18

Size/Duplication

Total Lines	104
Duplicated Lines	0 %

Test Coverage

Coverage

97.83%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	paramsIsRequestModel()	0	7	3
A	processModel()	0	9	2
A	getRequestData()	0	9	1
A	getModelRequestClasses()	0	10	3
A	__construct()	0	3	1
A	getErrorsFromValidationResult()	0	13	3
A	createValidator()	0	3	1
A	validateRequest()	0	7	2
A	createInstances()	0	8	2

<?php

declare(strict_types=1);

namespace Yiisoft\RequestModel;

use Psr\Http\Message\ServerRequestInterface;
use ReflectionClass;
use ReflectionException;
use ReflectionParameter;
use Yiisoft\Injector\Injector;
use Yiisoft\Validator\Result;
use Yiisoft\Validator\ResultSet;
use Yiisoft\Validator\Validator;

final class RequestModelFactory
{
    private Injector $injector;

    public function __construct(Injector $injector)
    {
        $this->injector = $injector;
    }

    /**
     * @param ServerRequestInterface $request
     * @param array|ReflectionParameter[] $handlerParams
     *
     * @return array
     * @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 ValidatableModelInterface) {
            $this->validateRequest($model, $requestData);
        }

        return $model;

The expression return $model could return the type Yiisoft\RequestModel\ValidatableModelInterface which is incompatible with the type-hinted return Yiisoft\RequestModel\RequestModelInterface. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param array|ReflectionParameter[] $handlerParams
     *
     * @return array
     */
    private function getModelRequestClasses(array $handlerParams): array
    {
        $modelClasses = [];
        foreach ($handlerParams as $param) {
            if ($this->paramsIsRequestModel($param)) {
                $modelClasses[] = $param->getType()->getName();
            }
        }

        return $modelClasses;
    }

    private function paramsIsRequestModel(ReflectionParameter $param): bool
    {
        if (!$param->hasType() || $param->getType()->isBuiltin()) {
            return false;
        }

        return (new ReflectionClass($param->getType()->getName()))->implementsInterface(RequestModelInterface::class);

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

    }

    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(),
        ];
    }

    private function validateRequest(ValidatableModelInterface $model, array $requestData): void
    {
        $requestDataSet = new RequestDataSet($requestData);
        $result = $this->createValidator($model)->validate($requestDataSet);
        $errors = $this->getErrorsFromValidationResult($result);
        if (!empty($errors)) {
            throw new RequestValidationException($errors);
        }
    }

    private function createValidator(ValidatableModelInterface $model): Validator
    {
        return new Validator($model->getRules());
    }

    private function getErrorsFromValidationResult(ResultSet $result): array
    {
        /**
         * @var $fieldResult Result
         */
        $errors = [];
        foreach ($result->getIterator() as $field => $fieldResult) {
            if (!empty($fieldResult->getErrors())) {
                $errors[$field] = $fieldResult->getErrors();
            }
        }

        return $errors;
    }
}