Overblog\GraphQLBundle\Resolver\AccessResolver

Complexity

Total Complexity

11

Size/Duplication

Total Lines	67
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.5%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	resolve()	0	15	3
C	filterResultUsingAccess()	0	40	7
A	hasAccess()	0	7	1

<?php

/*
 * This file is part of the OverblogGraphQLBundle package.
 *
 * (c) Overblog <http://github.com/overblog/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Overblog\GraphQLBundle\Resolver;

use Overblog\GraphQLBundle\Error\UserError;
use Overblog\GraphQLBundle\Error\UserWarning;
use Overblog\GraphQLBundle\Promise\PromiseInterface;
use Overblog\GraphQLBundle\Relay\Connection\Output\Connection;
use Overblog\GraphQLBundle\Relay\Connection\Output\Edge;

class AccessResolver
{
    public function resolve(callable $accessChecker, callable $resolveCallback, array $resolveArgs = [], $isMutation = false)
    {
        // operation is mutation and is mutation field
        if ($isMutation) {
            if (!$this->hasAccess($accessChecker, null, $resolveArgs)) {
                throw new UserError('Access denied to this field.');
            }

            $result = call_user_func_array($resolveCallback, $resolveArgs);
        } else {
            $result = $this->filterResultUsingAccess($accessChecker, $resolveCallback, $resolveArgs);
        }

        return $result;
    }

    private function filterResultUsingAccess(callable $accessChecker, callable $resolveCallback, array $resolveArgs = [])
    {
        $result = call_user_func_array($resolveCallback, $resolveArgs);

        $onFulFilled = function ($result) use ($accessChecker, $resolveArgs) {
            switch (true) {
                case is_array($result):
                    $result = array_map(
                        function ($object) use ($accessChecker, $resolveArgs) {
                            return $this->hasAccess($accessChecker, $object, $resolveArgs) ? $object : null;
                        },
                        $result
                    );
                    break;
                case $result instanceof Connection:
                    $result->edges = array_map(
                        function (Edge $edge) use ($accessChecker, $resolveArgs) {
                            $edge->node = $this->hasAccess($accessChecker, $edge->node, $resolveArgs) ? $edge->node : null;

                            return $edge;
                        },
                        $result->edges
                    );
                    break;
                default:
                    if (!$this->hasAccess($accessChecker, $result, $resolveArgs)) {
                        throw new UserWarning('Access denied to this field.');
                    }
                    break;
            }

            return $result;
        };

        if ($result instanceof  PromiseInterface) {
            return $result->then($onFulFilled);
        }

        return $onFulFilled($result);
    }

    private function hasAccess(callable $accessChecker, $object, array $resolveArgs = [])
    {
        $resolveArgs[] = $object;
        $access = (bool) call_user_func_array($accessChecker, $resolveArgs);

        return $access;
    }
}