Railt\Adapters\Webonyx\Input

Complexity

Total Complexity

21

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
C	resolveArguments()	0	27	7
A	__construct()	0	5	1
A	getQueryType()	0	4	1
A	getResolveInfo()	0	4	1
A	all()	0	4	1
A	get()	0	4	1
A	has()	0	4	1
A	getRelations()	0	4	1
A	getFieldName()	0	4	1
A	hasRelation()	0	4	1
A	getPath()	0	17	2
A	__debugInfo()	0	7	1
A	getAlias()	0	4	1
A	hasAlias()	0	4	1

<?php
/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Railt\Adapters\Webonyx;

use GraphQL\Type\Definition\ResolveInfo;
use Railt\Adapters\InputInterface;
use Railt\Reflection\Abstraction\ArgumentInterface;
use Railt\Reflection\Abstraction\Common\HasArgumentsInterface;
use Railt\Routing\Route;

/**
 * Class Input
 * @package Railt\Adapters\Webonyx
 */
class Input implements InputInterface
{
    /**
     * @var array
     */
    private $arguments = [];

    /**
     * @var ResolveInfo
     */
    private $info;

    /**
     * @var null|string
     */
    private $path;

    /**
     * @param HasArgumentsInterface $node
     * @param array $input
     * @return array
     * @throws \InvalidArgumentException
     */
    public static function resolveArguments(HasArgumentsInterface $node, array $input = []): array
    {
        $result = [];

        /** @var ArgumentInterface $default */
        foreach ($node->getArguments() as $default) {
            $name = $default->getName();

            if (
                !array_key_exists($name, $input) && // Empty argument
                !$default->hasDefaultValue() &&     // And has no default value
                $default->getType()->nonNull()      // And required
            ) {
                $message = 'Argument %s required for field %s';
                $field = $default->getParent()->getName();
                throw new \InvalidArgumentException(sprintf($message, $name, $field));
            }

            if (array_key_exists($name, $input)) {
                $result[$name] = $input[$name];
            } elseif ($default->hasDefaultValue()) {
                $result[$name] = $default->getDefaultValue();
            }
        }

        return $result;
    }

    /**
     * Request constructor.
     * @param array $arguments
     * @param ResolveInfo $info
     */
    public function __construct(array $arguments = [], ResolveInfo $info)
    {
        $this->info = $info;
        $this->arguments = $arguments;
    }

    /**
     * @return string
     */
    public function getQueryType(): string
    {
        return $this->info->operation->operation;
    }

    /**
     * @return ResolveInfo
     */
    public function getResolveInfo(): ResolveInfo
    {
        return $this->info;
    }

    /**
     * @return array
     */
    public function all(): array
    {
        return $this->arguments;
    }

    /**
     * @param string $argument
     * @param null $default
     * @return mixed|null
     */
    public function get(string $argument, $default = null)
    {
        return $this->arguments[$argument] ?? $default;
    }

    /**
     * @param string $argument
     * @return bool
     */
    public function has(string $argument): bool
    {
        return array_key_exists($argument, $this->arguments);
    }

    /**
     * TODO
     * @return iterable
     */
    public function getRelations(): iterable
    {
        throw new \LogicException(__METHOD__ . ' not implemented yet');
    }

    /**
     * @return string
     */
    public function getFieldName(): string
    {
        return $this->info->fieldName;
    }

    public function hasRelation(string $name): bool
    {
        throw new \LogicException(__METHOD__ . ' not implemented yet');
    }

    /**
     * @return string
     */
    public function getPath(): string
    {
        if ($this->path === null) {
            $path = $this->info->path;
            $path[count($path) - 1] = $this->getFieldName();

            // Remove array indexes
            $path = array_filter($path, 'is_string');

            // Remove empty values
            $path = array_filter($path, 'trim');

            $this->path = implode(Route::ACTION_DEPTH_DELIMITER, $path);
        }

        return $this->path;
    }

    /**
     * @return array
     */
    public function __debugInfo(): array
    {
        return [
            'path' => $this->path,
            'arguments' => $this->arguments
        ];
    }

    /**
     * @return string
     * @throws \LogicException
     */
    public function getAlias(): string
    {
        return $this->info->path[count($this->info->path) - 1];
    }

    /**
     * @return bool
     * @throws \LogicException
     */
    public function hasAlias(): bool
    {
        return $this->getAlias() !== $this->getFieldName();
    }
}