Andi\GraphQL\Type\AbstractInterfaceType

Complexity

Total Complexity

1

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
	makeObjectField()	0	4	?
A	addAdditionalField()	0	5	1
A	hp$0 ➔ makeObjectField()	0	4	1
A	getFields()	0	26	6
A	getObjectField()	0	21	5

<?php

declare(strict_types=1);

namespace Andi\GraphQL\Type;

use Andi\GraphQL\Definition\Field\ObjectFieldInterface;
use Andi\GraphQL\Definition\Type\InterfaceTypeInterface;
use Andi\GraphQL\Exception\CantResolveObjectFieldException;
use Andi\GraphQL\Field\AbstractAnonymousObjectField;
use Andi\GraphQL\Field\AbstractObjectField;
use GraphQL\Type\Definition as Webonyx;

/**
 * @phpstan-type ArgumentConfig array{
 *     name: string,
 *     type: string,
 *     mode: int,
 *     description?: string|null,
 *     deprecationReason?: string|null,
 *     defaultValue: mixed
 * }
 * @phpstan-type FieldConfig array{
 *     name: string,
 *     type: string,
 *     mode: int,
 *     description?: string|null,
 *     deprecationReason?: string|null,
 *     arguments: array<array-key, string|ArgumentConfig>
 * }
 */
abstract class AbstractInterfaceType extends AbstractType implements InterfaceTypeInterface, DynamicObjectTypeInterface
{
    /**
     * @var iterable<array-key, string|ObjectFieldInterface|Webonyx\FieldDefinition|FieldConfig>
     */
    protected iterable $fields;

    protected array $additionalFields = [];

    public function getFields(): iterable
    {
        /**
         * @psalm-suppress RedundantPropertyInitializationCheck
         * @psalm-suppress RedundantCondition
         * @psalm-suppress TypeDoesNotContainType
         */
        foreach ($this->fields ?? [] as $name => $field) {
            if ($field instanceof Webonyx\FieldDefinition || $field instanceof ObjectFieldInterface) {
                yield $field;

                continue;
            }

            if (\is_string($field) || \is_array($field)) {
                yield $this->getObjectField($name, $field);

                continue;
            }

            throw new CantResolveObjectFieldException(
                'Can\'t resolve ObjectField: wrong field configuration',
            );
        }

        yield from $this->additionalFields;
    }

    public function addAdditionalField(mixed $field): static
    {
        $this->additionalFields[] = $field;

        return $this;
    }

    private function getObjectField(int|string $name, string|array $field): AbstractObjectField
    {
        $fieldName = $field['name'] ?? $name;

        if (! \is_string($fieldName)) {
            throw new CantResolveObjectFieldException(
                'Can\'t resolve ObjectField: wrong configuration - undefined name',
            );
        }

        if (\is_string($field)) {

The condition is_string($field) is always false.

            return $this->makeObjectField($fieldName, ['type' => $field]);
        }

        if (! isset($field['type']) || ! \is_string($field['type'])) {
            throw new CantResolveObjectFieldException(
                'Can\'t resolve ObjectField: wrong configuration - undefined type',
            );
        }

        return $this->makeObjectField($fieldName, $field);
    }

    private function makeObjectField(string $name, array $field): AbstractObjectField
    {
        /** @psalm-suppress InternalClass */
        return new class($name, $field) extends AbstractAnonymousObjectField {};
    }
}