Digia\GraphQL\Type\Definition\FieldsTrait

Complexity

Total Complexity

11

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getFields()	0	5	1
A	addField()	0	5	1
B	defineFieldMap()	0	45	4
A	setFields()	0	5	1
A	defineFieldMapIfNecessary()	0	7	2
A	addFields()	0	7	2

<?php

namespace Digia\GraphQL\Type\Definition;

use function Digia\GraphQL\Type\isAssocArray;
use function Digia\GraphQL\Type\isValidResolver;
use function Digia\GraphQL\Type\resolveThunk;
use function Digia\GraphQL\Util\invariant;
use function Digia\GraphQL\Util\toString;

trait FieldsTrait
{

    /**
     * @var array|callable
     */
    private $_fieldsThunk;

    /**
     * @var Field[]
     */
    private $_fieldMap = [];

    /**
     * @var bool
     */
    private $_isFieldMapDefined = false;

    /**
     * @param Field $field
     * @return $this
     * @throws \Exception
     */
    public function addField(Field $field)
    {
        $this->_fieldMap[$field->getName()] = $field;

        return $this;
    }

    /**
     * @param array $fields
     * @return $this
     * @throws \Exception
     */
    public function addFields(array $fields)
    {
        foreach ($fields as $field) {
            $this->addField($field);
        }

        return $this;
    }

    /**
     * @return Field[]
     * @throws \Exception
     */
    public function getFields(): array
    {
        $this->defineFieldMapIfNecessary();

        return $this->_fieldMap;
    }

    /**
     * @throws \Exception
     */
    protected function defineFieldMapIfNecessary(): void
    {
        // Fields are built lazily to avoid concurrency issues.
        if (!$this->_isFieldMapDefined) {
            $this->_fieldMap = array_merge($this->defineFieldMap($this->_fieldsThunk), $this->_fieldMap);

            $this->_isFieldMapDefined = true;
        }
    }

    /**
     * @param array|callable $fieldsThunk
     * @return $this
     */
    protected function setFields($fieldsThunk)
    {
        $this->_fieldsThunk = $fieldsThunk;

        return $this;
    }

    /**
     * @param mixed $fieldsThunk
     * @return array
     * @throws \Exception
     */
    protected function defineFieldMap($fieldsThunk): array
    {
        $fields = resolveThunk($fieldsThunk) ?: [];

        invariant(
            isAssocArray($fields),
            sprintf(
                '%s fields must be an associative array with field names as key or a callable which returns such an array.',
                $this->getName()

It seems like getName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            )
        );

        $fieldMap = [];

        foreach ($fields as $fieldName => $fieldConfig) {
            invariant(
                is_array($fieldConfig),
                sprintf('%s.%s field config must be an array', $this->getName(), $fieldName)
            );

            invariant(
                !isset($fieldConfig['isDeprecated']),
                sprintf(
                    '%s.%s should provide "deprecationReason" instead of "isDeprecated".',
                    $this->getName(),
                    $fieldName
                )
            );

            if (isset($fieldConfig['resolve'])) {
                invariant(
                    isValidResolver($fieldConfig['resolve']),
                    sprintf(
                        '%s.%s field resolver must be a function if provided, but got: %s',
                        $this->getName(),
                        $fieldName,
                        toString($fieldConfig['resolve'])
                    )
                );
            }

            $fieldMap[$fieldName] = new Field(array_merge($fieldConfig, ['name' => $fieldName]));
        }

        return $fieldMap;
    }

}