Digia\GraphQL\Schema\Resolver\ResolverRegistry

Complexity

Total Complexity

14

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getTypeResolver()	0	9	2
A	getFieldResolver()	0	21	5
A	registerResolvers()	0	8	3
A	applyMiddleware()	0	13	1
A	getResolver()	0	3	1
A	register()	0	3	1
A	__construct()	0	5	1

<?php

namespace Digia\GraphQL\Schema\Resolver;

use Digia\GraphQL\Execution\ResolveInfo;

class ResolverRegistry implements ResolverRegistryInterface
{
    /**
     * @var ResolverInterface[]
     */
    protected $resolverMap;

    /**
     * @var ResolverMiddlewareInterface[]
     */
    protected $middleware;

    /**
     * ResolverMapRegistry constructor.
     * @param array $resolvers
     */
    public function __construct(array $resolvers = [], array $middleware = [])
    {
        $this->middleware = $middleware;

        $this->registerResolvers($resolvers);
    }

    /**
     * @inheritdoc
     */
    public function register(string $typeName, ResolverInterface $resolver): void
    {
        $this->resolverMap[$typeName] = $resolver;
    }

    /**
     * @inheritdoc
     */
    public function getFieldResolver(string $typeName, string $fieldName): ?callable
    {
        $resolver = $this->getResolver($typeName);

        if (null === $resolver) {
            return null;
        }

        $resolver = $resolver instanceof ResolverCollection
            ? $resolver->getResolver($fieldName)
            : $resolver;

        $resolveCallback = $resolver instanceof ResolverInterface
            ? $resolver->getResolveCallback()
            : $resolver;

        if (!empty($this->middleware)) {
            return $this->applyMiddleware($resolveCallback, \array_reverse($this->middleware));

It seems like $resolveCallback can also be of type null; however, parameter $resolveCallback of Digia\GraphQL\Schema\Resolver\ResolverRegistry::applyMiddleware() does only seem to accept callable, maybe add an additional type check?

        }

        return $resolveCallback;
    }

    /**
     * @inheritdoc
     */
    public function getTypeResolver(string $typeName): ?callable
    {
        $resolver = $this->getResolver($typeName);

        if ($resolver instanceof ResolverInterface) {
            return $resolver->getTypeResolver();
        }

        return null;
    }

    /**
     * @inheritdoc
     */
    public function getResolver(string $typeName): ?ResolverInterface
    {
        return $this->resolverMap[$typeName] ?? null;
    }

    /**
     * @param array $resolvers
     */
    protected function registerResolvers(array $resolvers): void
    {
        foreach ($resolvers as $typeName => $resolver) {
            if (\is_array($resolver)) {
                $resolver = new ResolverCollection($resolver);
            }

            $this->register($typeName, $resolver);
        }
    }

    /**
     * @param callable $resolveCallback
     * @param array    $middleware
     * @return callable
     */
    protected function applyMiddleware(callable $resolveCallback, array $middleware): callable
    {
        return \array_reduce(
            $middleware,
            function (callable $resolveCallback, ResolverMiddlewareInterface $middleware) {
                return function ($rootValue, array $args, $contextValues = null, ?ResolveInfo $info = null) use (
                    $resolveCallback,
                    $middleware
                ) {
                    return $middleware->resolve($resolveCallback, $rootValue, $args, $contextValues, $info);
                };
            },
            $resolveCallback
        );
    }
}