railt / webonyx-adapter

Adapter.php

<?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\Executor\ExecutionResult;
use GraphQL\GraphQL;
use GraphQL\Type\Schema;

The type GraphQL\Type\Schema was not found. Maybe you did not declare it correctly or list all dependencies?

use Railt\Adapters\AdapterInterface;

The type Railt\Adapters\AdapterInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Railt\Adapters\Webonyx\Builders\SchemaBuilder;
use Railt\Container\ContainerInterface;

The type Railt\Container\ContainerInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Railt\Http\RequestInterface;

The type Railt\Http\RequestInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Railt\Http\Response;

The type Railt\Http\Response was not found. Maybe you did not declare it correctly or list all dependencies?

use Railt\Http\ResponseInterface;

The type Railt\Http\ResponseInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Railt\Reflection\Contracts\Definitions\SchemaDefinition;

The type Railt\Reflection\Contracts\Definitions\SchemaDefinition was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Class Adapter
 */
class Adapter implements AdapterInterface
{
    /**
     * @var Registry
     */
    private $registry;

    /**
     * @var bool
     */
    private $debug;

    /**
     * Adapter constructor.
     * @param ContainerInterface $container
     * @param bool $debug
     */
    public function __construct(ContainerInterface $container, bool $debug = false)
    {
        $this->debug      = $debug;
        $this->registry   = new Registry($container);
        $container->instance(FieldResolver::class, new FieldResolver($container));
    }

    /**
     * @param SchemaDefinition $schema
     * @param RequestInterface $request
     * @return ResponseInterface
     * @throws \GraphQL\Error\InvariantViolation
     * @throws \Throwable
     */
    public function request(SchemaDefinition $schema, RequestInterface $request): ResponseInterface
    {
        $this->registry->getContainer()->instance(RequestInterface::class, $request);

        try {
            $executor = $this->buildExecutor($schema, $request);

            /** @var ExecutionResult $result */
            $result = $executor();

            return new Response((array)$result->data, $result->errors);
        } catch (\Throwable $e) {
            if ($this->debug) {
                throw $e;
            }

            return Response::error($e);
        }
    }

    /**
     * @param SchemaDefinition $reflection
     * @param RequestInterface $request
     * @return \Closure
     * @throws \GraphQL\Error\InvariantViolation
     */
    private function buildExecutor(SchemaDefinition $reflection, RequestInterface $request): \Closure
    {
        $schema = $this->buildSchema($reflection);

        if ($this->debug) {
            $schema->assertValid();
        }

        return function ($rootValue = null, $context = null) use ($reflection, $schema, $request): ExecutionResult {

The parameter $context is not used and could be removed.

            return GraphQL::executeQuery(

The method executeQuery() does not exist on GraphQL\GraphQL. Did you maybe mean execute()?

                $schema,
                $request->getQuery(),
                $rootValue,
                $reflection,
                $request->getVariables(),
                $request->getOperation(),
                null /** Validations */
            );
        };
    }

    /**
     * @param SchemaDefinition $schema
     * @return Schema
     */
    protected function buildSchema(SchemaDefinition $schema): Schema
    {
        $builder = new SchemaBuilder($schema, $this->registry);

        return $builder->build();
    }
}