Overblog\GraphQLBundle\Config\Processor\BuilderProcessor

Complexity

Total Complexity

40

Size/Duplication

Total Lines	230
Duplicated Lines	0 %

Test Coverage

Coverage

99.03%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	processFieldsBuilders()	0	26	4
A	checkBuilderClass()	0	23	4
B	process()	0	25	7
A	addBuilderClass()	0	4	1
A	getBuilder()	0	24	4
B	processFieldArgumentsBuilders()	0	23	9
B	processFieldBuilders()	0	45	11

<?php

declare(strict_types=1);

namespace Overblog\GraphQLBundle\Config\Processor;

use Overblog\GraphQLBundle\Definition\Builder\MappingInterface;
use Overblog\GraphQLBundle\Relay\Connection\BackwardConnectionArgsDefinition;
use Overblog\GraphQLBundle\Relay\Connection\ConnectionArgsDefinition;
use Overblog\GraphQLBundle\Relay\Connection\ForwardConnectionArgsDefinition;
use Overblog\GraphQLBundle\Relay\Mutation\MutationFieldDefinition;
use Overblog\GraphQLBundle\Relay\Node\GlobalIdFieldDefinition;
use Overblog\GraphQLBundle\Relay\Node\NodeFieldDefinition;
use Overblog\GraphQLBundle\Relay\Node\PluralIdentifyingRootFieldDefinition;
use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;

final class BuilderProcessor implements ProcessorInterface
{
    public const BUILDER_FIELD_TYPE = 'field';
    public const BUILDER_FIELDS_TYPE = 'fields';
    public const BUILDER_ARGS_TYPE = 'args';

    public const BUILDER_TYPES = [
        self::BUILDER_FIELD_TYPE,
        self::BUILDER_FIELDS_TYPE,
        self::BUILDER_ARGS_TYPE,
    ];

    /** @var MappingInterface[] */
    private static $builderClassMap = [
        self::BUILDER_ARGS_TYPE => [
            'Relay::ForwardConnection' => ForwardConnectionArgsDefinition::class,
            'Relay::BackwardConnection' => BackwardConnectionArgsDefinition::class,
            'Relay::Connection' => ConnectionArgsDefinition::class,
        ],
        self::BUILDER_FIELD_TYPE => [
            'Relay::Mutation' => MutationFieldDefinition::class,
            'Relay::GlobalId' => GlobalIdFieldDefinition::class,
            'Relay::Node' => NodeFieldDefinition::class,
            'Relay::PluralIdentifyingRoot' => PluralIdentifyingRootFieldDefinition::class,
        ],
        self::BUILDER_FIELDS_TYPE => [],
    ];

    /**
     * {@inheritdoc}
     */
    public static function process(array $configs): array
    {
        $addedTypes = [];

        foreach ($configs as &$config) {
            if (isset($config['config']['builders']) && \is_array($config['config']['builders'])) {
                ['fields' => $buildersFields, 'types' => $buildersTypes] = self::processFieldsBuilders($config['config']['builders']);

                $config['config']['fields'] = isset($config['config']['fields']) ? \array_merge($buildersFields, $config['config']['fields']) : $buildersFields;

                $addedTypes = \array_merge($addedTypes, $buildersTypes);

                unset($config['config']['builders']);
            }

            if (isset($config['config']['fields']) && \is_array($config['config']['fields'])) {
                ['fields' => $buildersFields, 'types' => $buildersTypes] = self::processFieldBuilders($config['config']['fields']);

                $config['config']['fields'] = $buildersFields;

                $addedTypes = \array_merge($addedTypes, $buildersTypes);
            }
        }

        return \array_merge($configs, $addedTypes);
    }

    public static function addBuilderClass($name, $type, $builderClass): void
    {
        self::checkBuilderClass($builderClass, $type);
        self::$builderClassMap[$type][$name] = $builderClass;
    }

    /**
     * @param string $builderClass
     * @param string $type
     */
    private static function checkBuilderClass($builderClass, $type): void
    {
        $interface = MappingInterface::class;

        if (!\is_string($builderClass)) {

The condition is_string($builderClass) is always true.

            throw new \InvalidArgumentException(
                \sprintf('%s builder class should be string, but %s given.', \ucfirst($type), \gettype($builderClass))
            );
        }

        if (!\class_exists($builderClass)) {
            throw new \InvalidArgumentException(
                \sprintf('%s builder class "%s" not found.', \ucfirst($type), $builderClass)
            );
        }

        if (!\is_subclass_of($builderClass, $interface)) {
            throw new \InvalidArgumentException(
                \sprintf(
                    '%s builder class should implement "%s", but "%s" given.',
                    \ucfirst($type),
                    $interface,
                    $builderClass
                )
            );
        }
    }

    private static function processFieldBuilders(array $fields)
    {
        $types = [];

        foreach ($fields as &$field) {
            $fieldBuilderName = null;

            if (isset($field['builder']) && \is_string($field['builder'])) {
                $fieldBuilderName = $field['builder'];
                unset($field['builder']);
            } elseif (\is_string($field)) {
                @\trigger_error(
                    'The builder short syntax (Field: Builder => Field: {builder: Builder}) is deprecated as of 0.7 and will be removed in 0.12. '.
                    'It will be replaced by the field type short syntax (Field: Type => Field: {type: Type})',
                    \E_USER_DEPRECATED
                );
                $fieldBuilderName = $field;
            }

            $builderConfig = [];
            if (isset($field['builderConfig'])) {
                if (\is_array($field['builderConfig'])) {
                    $builderConfig = $field['builderConfig'];
                }
                unset($field['builderConfig']);
            }

            if ($fieldBuilderName) {
                $mapping = self::getBuilder($fieldBuilderName, self::BUILDER_FIELD_TYPE)->toMappingDefinition($builderConfig);

                $fieldMapping = $mapping['field'] ?? $mapping;
                $field = \is_array($field) ? \array_merge($fieldMapping, $field) : $fieldMapping;

                if (isset($mapping['field'], $mapping['types'])) {
                    $types = \array_merge($types, $mapping['types']);
                }
            }
            if (isset($field['argsBuilder'])) {
                $field = self::processFieldArgumentsBuilders($field);
            }
        }

        return [
            'fields' => $fields,
            'types' => $types,
        ];
    }

    private static function processFieldsBuilders(array $builders)
    {
        $fields = [];
        $types = [];

        foreach ($builders as $builder) {
            $builderName = $builder['builder'];
            $builderConfig = null;

            if (isset($builder['builderConfig'])) {
                $builderConfig = $builder['builderConfig'];
            }

            $mapping = self::getBuilder($builderName, self::BUILDER_FIELDS_TYPE)->toMappingDefinition($builderConfig);

            $fieldsMapping = $mapping['fields'] ?? $mapping;
            $fields = \array_merge($fields, $fieldsMapping);

            if (isset($mapping['fields'], $mapping['types'])) {
                $types = \array_merge($types, $mapping['types']);
            }
        }

        return [
            'fields' => $fields,
            'types' => $types,
        ];
    }

    /**
     * @param string $name
     * @param string $type
     *
     * @return MappingInterface
     *
     * @throws InvalidConfigurationException if builder class not define
     */
    private static function getBuilder($name, $type)
    {
        static $builders = [];
        if (isset($builders[$type][$name])) {
            return $builders[$type][$name];
        }

        $builderClassMap = self::$builderClassMap[$type];

        if (isset($builderClassMap[$name])) {
            return $builders[$type][$name] = new $builderClassMap[$name]();
        }
        // deprecated relay builder name ?
        $newName = 'Relay::'.\rtrim($name, 'Args');
        if (isset($builderClassMap[$newName])) {
            @\trigger_error(
                \sprintf('The "%s" %s builder is deprecated as of 0.7 and will be removed in 0.12. Use "%s" instead.', $name, $type, $newName),
                \E_USER_DEPRECATED
            );

            return $builders[$type][$newName] = new $builderClassMap[$newName]();
        }

        throw new InvalidConfigurationException(\sprintf('%s builder "%s" not found.', \ucfirst($type), $name));
    }

    private static function processFieldArgumentsBuilders(array $field)
    {
        $argsBuilderName = null;

        if (\is_string($field['argsBuilder'])) {
            $argsBuilderName = $field['argsBuilder'];
        } elseif (isset($field['argsBuilder']['builder']) && \is_string($field['argsBuilder']['builder'])) {
            $argsBuilderName = $field['argsBuilder']['builder'];
        }

        $builderConfig = [];
        if (isset($field['argsBuilder']['config']) && \is_array($field['argsBuilder']['config'])) {
            $builderConfig = $field['argsBuilder']['config'];
        }

        if ($argsBuilderName) {
            $args = self::getBuilder($argsBuilderName, self::BUILDER_ARGS_TYPE)->toMappingDefinition($builderConfig);
            $field['args'] = isset($field['args']) && \is_array($field['args']) ? \array_merge($args, $field['args']) : $args;
        }

        unset($field['argsBuilder']);

        return $field;
    }
}