Butler\Graphql\Concerns\HandlesGraphqlRequests

Complexity

Total Complexity

69

Size/Duplication

Total Lines	354
Duplicated Lines	0 %

Test Coverage

Coverage

94.01%

Importance

Changes	2
Bugs	0	Features	0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	schemaPath()	0	3	1
A	beforeExecutionHook()	0	7	1
A	reportException()	0	3	1
A	debugFlags()	0	10	3
A	decorateTypeConfig()	0	6	2
A	schema()	0	3	1
A	shouldDecorateWithResolveType()	0	4	2
B	errorFormatter()	0	44	7
A	__invoke()	0	43	2
A	resolveClassName()	0	11	3
A	returnTypeIsLeaf()	0	7	2
A	namespace()	0	3	1
A	resolveField()	0	17	5
A	fieldFromArray()	0	15	4
A	queriesNamespace()	0	3	1
A	typeFromArray()	0	4	3
A	typesNamespace()	0	3	1
A	decorateResponse()	0	6	3
A	mutationsNamespace()	0	3	1
A	fieldFromObject()	0	15	3
A	typeFromParentResolver()	0	8	3
A	fieldIsBackedEnum()	0	3	2
A	resolveType()	0	6	1
A	propertyNames()	0	7	1
A	typeFromBaseClass()	0	4	2
A	resolveTypeMethodName()	0	7	2
A	make()	0	11	4
A	typeFromObject()	0	4	2
A	resolveFieldMethodName()	0	7	2
A	resolverForField()	0	8	3

<?php

namespace Butler\Graphql\Concerns;

use Butler\Graphql\DataLoader;
use Exception;
use GraphQL\Error\DebugFlag;
use GraphQL\Error\Error as GraphqlError;
use GraphQL\Error\FormattedError;
use GraphQL\Executor\ExecutionResult;
use GraphQL\Executor\Promise\PromiseAdapter;
use GraphQL\GraphQL;
use GraphQL\Language\AST\DocumentNode;
use GraphQL\Language\AST\InterfaceTypeDefinitionNode;
use GraphQL\Language\AST\TypeDefinitionNode;
use GraphQL\Language\AST\UnionTypeDefinitionNode;
use GraphQL\Language\Parser;
use GraphQL\Type\Definition\LeafType;
use GraphQL\Type\Definition\ResolveInfo;
use GraphQL\Type\Definition\WrappingType;
use GraphQL\Type\Schema;
use GraphQL\Utils\BuildSchema;
use Illuminate\Contracts\Debug\ExceptionHandler;
use Illuminate\Database\Eloquent\MissingAttributeException;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Http\Request;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
use Symfony\Component\HttpKernel\Exception\HttpException;

use function Amp\call;

trait HandlesGraphqlRequests
{
    private $classCache;
    private $namespaceCache;

    /**
     * Invoke the Graphql request handler.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return array
     */
    public function __invoke(Request $request)
    {
        $this->classCache = [];
        $this->namespaceCache = null;

        $loader = app(DataLoader::class);

        $query = $request->input('query');
        $variables = $request->input('variables');
        $operationName = $request->input('operationName');

        try {
            $schema = BuildSchema::build($this->schema(), [$this, 'decorateTypeConfig']);

            $source = Parser::parse($query);

            $this->beforeExecutionHook($schema, $source, $operationName, $variables);

            /** @var \GraphQL\Executor\ExecutionResult */
            $result = null;

            GraphQL::promiseToExecute(
                app(PromiseAdapter::class),
                $schema,
                $source,
                null, // root
                compact('loader'), // context
                $variables,
                $operationName,
                [$this, 'resolveField'],
                null // validationRules
            )->then(function ($value) use (&$result) {
                $result = $value;
            });

            $loader->run();
        } catch (GraphqlError $e) {
            $result = new ExecutionResult(null, [$e]);
        }

        $result->setErrorFormatter([$this, 'errorFormatter']);

        return $this->decorateResponse($result->toArray($this->debugFlags()));
    }

    public function beforeExecutionHook(
        Schema $schema,
        DocumentNode $query,
        string $operationName = null,
        $variables = null
    ): void {
        return;
    }

    public function errorFormatter(GraphqlError $graphqlError)
    {
        $formattedError = FormattedError::createFromException($graphqlError);
        $throwable = $graphqlError->getPrevious();

        $this->reportException(
            $throwable instanceof Exception ? $throwable : $graphqlError

$throwable is always a sub-type of Exception.

        );

        if (
            $throwable instanceof HttpException &&
            $throwable->getStatusCode() >= 400 &&
            $throwable->getStatusCode() < 500
        ) {
            return array_merge($formattedError, [
                'message' => $throwable->getMessage(),
                'extensions' => [
                    'category' => 'client',
                    'code' => $throwable->getStatusCode(),
                ],
            ]);
        }

        if ($throwable instanceof ModelNotFoundException) {
            return array_merge($formattedError, [
                'message' => class_basename($throwable->getModel()) . ' not found.',
                'extensions' => [
                    'category' => 'client',
                    'code' => 404,
                ],
            ]);
        }

        if ($throwable instanceof ValidationException) {
            return array_merge($formattedError, [
                'message' => $throwable->getMessage(),
                'extensions' => [
                    'category' => 'validation',
                    'validation' => $throwable->errors(),
                ],
            ]);
        }

        return $formattedError;
    }

    public function reportException(Exception $exception)
    {
        app(ExceptionHandler::class)->report($exception);
    }

    public function schema()
    {
        return file_get_contents($this->schemaPath());
    }

    public function schemaPath()
    {
        return config('butler.graphql.schema');
    }

    public function decorateTypeConfig(array $config, TypeDefinitionNode $typeDefinitionNode)
    {
        if ($this->shouldDecorateWithResolveType($typeDefinitionNode)) {
            $config['resolveType'] = [$this, 'resolveType'];
        }
        return $config;
    }

    protected function shouldDecorateWithResolveType(TypeDefinitionNode $typeDefinitionNode)
    {
        return $typeDefinitionNode instanceof InterfaceTypeDefinitionNode
            || $typeDefinitionNode instanceof UnionTypeDefinitionNode;
    }

    public function debugFlags()
    {
        $flags = 0;
        if (config('butler.graphql.include_debug_message')) {
            $flags |= DebugFlag::INCLUDE_DEBUG_MESSAGE;
        }
        if (config('butler.graphql.include_trace')) {
            $flags |= DebugFlag::INCLUDE_TRACE;
        }
        return $flags;
    }

    public function resolveField($source, $args, $context, ResolveInfo $info)
    {
        if ($resolver = $this->resolverForField($info)) {
            $field = $resolver($source, $args, $context, $info);
        } else {
            $field = $this->fieldFromArray($source, $args, $context, $info)
                ?? $this->fieldFromObject($source, $args, $context, $info);
        }

        if ($this->fieldIsBackedEnum($field) && $this->returnTypeIsLeaf($info)) {
            $field = $field->value;
        }

        return call(static function () use ($field, $source, $args, $context, $info) {
            return $field instanceof \Closure
                ? $field($source, $args, $context, $info)
                : $field;
        });
    }

    public function resolveType($source, $context, ResolveInfo $info)
    {
        return $this->typeFromArray($source, $context, $info)
            ?? $this->typeFromObject($source, $context, $info)
            ?? $this->typeFromParentResolver($source, $context, $info)
            ?? $this->typeFromBaseClass($source, $context, $info);
    }

    public function resolverForField(ResolveInfo $info)
    {
        $className = $this->resolveClassName($info);
        $methodName = $this->resolveFieldMethodName($info);

        if ($resolver = $this->make($className)) {
            if (method_exists($resolver, $methodName)) {
                return fn (...$args) => $resolver->{$methodName}(...$args);
            }
        }
    }

    public function fieldFromArray($source, $args, $context, ResolveInfo $info)
    {
        if (is_array($source) || $source instanceof \ArrayAccess) {
            return collect($this->propertyNames($info))

$this->propertyNames($info) of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

                ->map(function ($propertyName) use ($source) {
                    try {
                        return $source[$propertyName] ?? null;
                    } catch (MissingAttributeException) {
                        return null;
                    }
                })
                ->reject(function ($value) {
                    return is_null($value);
                })
                ->first();
        }
    }

    public function fieldFromObject($source, $args, $context, ResolveInfo $info)
    {
        if (is_object($source)) {
            return collect($this->propertyNames($info))

$this->propertyNames($info) of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

                ->map(function ($propertyName) use ($source) {
                    try {
                        return $source->{$propertyName} ?? null;
                    } catch (MissingAttributeException) {

catch (\Illuminate\Database\Eloquent\MissingAttributeException) is not reachable.

                        return null;
                    }
                })
                ->reject(function ($value) {
                    return is_null($value);
                })
                ->first();
        }
    }

    public function fieldIsBackedEnum($field): bool
    {
        return function_exists('enum_exists') && $field instanceof \BackedEnum;

The type BackedEnum was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    public function typeFromArray($source, $context, ResolveInfo $info)
    {
        if (is_array($source) || $source instanceof \ArrayAccess) {
            return $source['__typename'] ?? null;
        }
    }

    public function typeFromObject($source, $context, ResolveInfo $info)
    {
        if (is_object($source)) {
            return $source->__typename ?? null;
        }
    }

    public function typeFromParentResolver($source, $context, ResolveInfo $info)
    {
        $className = $this->resolveClassName($info);
        $methodName = $this->resolveTypeMethodName($info);

        if ($resolver = $this->make($className)) {
            if (method_exists($resolver, $methodName)) {
                return $resolver->{$methodName}($source, $context, $info);
            }
        }
    }

    public function typeFromBaseClass($source, $context, ResolveInfo $info)
    {
        if (is_object($source)) {
            return class_basename($source);
        }
    }

    public function propertyNames(ResolveInfo $info): array
    {
        return collect([

array(Illuminate\Support\Str::snake($info->fieldName), Illuminate\Support\Str::camel($info->fieldName), Illuminate\Support\Str::kebab(Illuminate\Support\Str::camel($info->fieldName))) of type array<integer,string> is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            Str::snake($info->fieldName),
            Str::camel($info->fieldName),
            Str::kebab(Str::camel($info->fieldName)),
        ])->unique()->toArray();
    }

    protected function resolveClassName(ResolveInfo $info): string
    {
        if ($info->parentType->name === 'Query') {
            return $this->queriesNamespace() . Str::studly($info->fieldName);
        }

        if ($info->parentType->name === 'Mutation') {
            return $this->mutationsNamespace() . Str::studly($info->fieldName);
        }

        return $this->typesNamespace() . Str::studly($info->parentType->name);
    }

    public function resolveFieldMethodName(ResolveInfo $info): string
    {
        if (in_array($info->parentType->name, ['Query', 'Mutation'])) {
            return '__invoke';
        }

        return Str::camel($info->fieldName);
    }

    public function resolveTypeMethodName(ResolveInfo $info): string
    {
        if (in_array($info->parentType->name, ['Query', 'Mutation'])) {
            return 'resolveType';
        }

        return 'resolveTypeFor' . ucfirst(Str::camel($info->fieldName));
    }

    public function namespace(): string
    {
        return $this->namespaceCache ?? $this->namespaceCache = config('butler.graphql.namespace');
    }

    public function queriesNamespace(): string
    {
        return $this->namespace() . 'Queries\\';
    }

    public function mutationsNamespace(): string
    {
        return $this->namespace() . 'Mutations\\';
    }

    public function typesNamespace(): string
    {
        return $this->namespace() . 'Types\\';
    }

    public function returnTypeIsLeaf(ResolveInfo $info): bool
    {
         $returnType = $info->returnType instanceof WrappingType
            ? $info->returnType->getWrappedType(true)
            : $info->returnType;

         return $returnType instanceof LeafType;
    }

    public function decorateResponse(array $data): array
    {
        if (app()->bound('debugbar') && app('debugbar')->isEnabled()) {
            $data['debug'] = app('debugbar')->getData();
        }
        return $data;
    }

    protected function make(string $className)
    {
        if (array_key_exists($className, $this->classCache)) {
            return $this->classCache[$className];
        }

        $class = app()->has($className) || class_exists($className)
            ? app($className)
            : null;

        return $this->classCache[$className] = $class;
    }
}