Hyde\Publications\Actions\PublicationSchemaValidator

Complexity

Total Complexity

14

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	6	1
A	validateFields()	0	4	2
A	evaluateFieldValidators()	0	5	1
A	validate()	0	4	1
A	call()	0	3	1
A	mapRulesInput()	0	5	1
A	makeValidator()	0	3	1
A	errors()	0	5	1
A	__construct()	0	3	1
A	makePropertyValidator()	0	15	1
A	makeFieldsValidators()	0	11	3

<?php

declare(strict_types=1);

namespace Hyde\Publications\Actions;

use stdClass;
use Hyde\Facades\Filesystem;
use Illuminate\Contracts\Validation\Validator;

use function collect;
use function is_array;
use function validator;
use function json_decode;

/**
 * @see \Hyde\Publications\Testing\Feature\PublicationSchemaValidatorTest
 */
class PublicationSchemaValidator
{
    protected stdClass $schema;

    protected Validator $schemaValidator;
    protected array $fieldValidators = [];

    public static function call(string $publicationTypeName): static
    {
        return (new self($publicationTypeName))->__invoke();
    }

    public function __construct(string $publicationTypeName)
    {
        $this->schema = json_decode(Filesystem::getContents("$publicationTypeName/schema.json"));
    }

    /** @return $this */
    public function __invoke(): static
    {
        $this->makePropertyValidator();
        $this->makeFieldsValidators();

        return $this;
    }

    /** @throws \Illuminate\Validation\ValidationException */
    public function validate(): void
    {
        $this->schemaValidator->validate();
        $this->validateFields();
    }

    /** @return array<string, Validator|array */

The doc comment array<string, Validator|array at position 6 could not be parsed: Expected '>' at position 6, but found 'array'.

    public function errors(): array
    {
        return [
            'schema' => $this->schemaValidator->errors()->all(),
            'fields' => $this->evaluateFieldValidators(),
        ];
    }

    protected function makePropertyValidator(): void
    {
        $rules = [
            'name' => 'required|string',
            'canonicalField' => 'nullable|string',
            'detailTemplate' => 'nullable|string',
            'listTemplate' => 'nullable|string',
            'sortField' => 'nullable|string',
            'sortAscending' => 'nullable|boolean',
            'pageSize' => 'nullable|integer',
            'fields' => 'nullable|array',
            'directory' => 'nullable|prohibited',
        ];

        $this->schemaValidator = $this->makeValidator($rules, $this->schema);
    }

    protected function makeFieldsValidators(): void
    {
        $rules = [
            'type' => 'required|string',
            'name' => 'required|string',
            'rules' => 'nullable|array',
        ];

        if (is_array($this->schema->fields)) {
            foreach ($this->schema->fields as $field) {
                $this->fieldValidators[] = $this->makeValidator($rules, $field);
            }
        }
    }

    /** @return array<array-key, array<array-key, string>> */

The doc comment array<array-key, array<array-key, string>> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, array<array-key, string>>.

    protected function evaluateFieldValidators(): array
    {
        return collect($this->fieldValidators)->map(function (Validator $validator): array {

$this->fieldValidators of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            return $validator->errors()->all();
        })->all();
    }

    protected function validateFields(): void
    {
        foreach ($this->fieldValidators as $validator) {
            $validator->validate();
        }
    }

    protected function makeValidator(array $rules, stdClass $input): Validator
    {
        return validator($this->mapRulesInput($rules, $input), $rules);
    }

    protected function mapRulesInput(array $rules, stdClass $input): array
    {
        return collect($rules)->mapWithKeys(function (string $rule, string $key) use ($input): array {

$rules of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            return [$key => $input->{$key} ?? null];
        })->all();
    }
}