Railt\CarbonExtension\Extension

Complexity

Total Complexity

6

Size/Duplication

Total Lines	59
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

0%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	boot()	0	6	1
A	listen()	0	15	2
A	isCarbonField()	0	4	2
A	extend()	0	6	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\CarbonExtension;

use Railt\CarbonExtension\TypeDefinition\FormatArgument;
use Railt\Foundation\Events\TypeBuilding;
use Railt\Foundation\Extensions\BaseExtension;
use Railt\Io\File;
use Railt\Routing\Contracts\RouterInterface;
use Railt\SDL\Contracts\Definitions\TypeDefinition;
use Railt\SDL\Contracts\Dependent\FieldDefinition;
use Railt\SDL\Reflection\Builder\Dependent\FieldBuilder;
use Railt\SDL\Schema\CompilerInterface as Compiler;
use Symfony\Component\EventDispatcher\EventDispatcherInterface as Events;

/**
 * Class Extension
 */
class Extension extends BaseExtension
{
    /**
     * @var string Path to graphql schema file
     */
    private const GRAPHQL_DATETIME = __DIR__ . '/../resources/datetime.graphqls';

    /**
     * @param Compiler $compiler
     * @throws \Railt\Io\Exception\NotReadableException
     */
    public function boot(Compiler $compiler): void
    {
        $compiler->compile(File::fromPathname(self::GRAPHQL_DATETIME));

It seems like \Railt\Io\File::fromPathname(self::GRAPHQL_DATETIME) targeting Railt\Io\File::fromPathname() can also be of type object<Railt\Io\File>; however, Railt\SDL\Schema\CompilerInterface::compile() does only seem to accept object<Railt\Io\Readable>, maybe add an additional type check?

        $this->call(\Closure::fromCallable([$this, 'listen']));
    }

    /**
     * @param Events $listener
     * @param Compiler $compiler
     * @param RouterInterface $router
     */
    private function listen(Events $listener, Compiler $compiler, RouterInterface $router): void
    {
        $controller = $this->make(CarbonController::class);

        $invoke = function (TypeBuilding $event) use ($compiler, $router, $controller): void {
            if ($this->isCarbonField($event->getType())) {
                $this->extend($compiler, $event->getType());

$event->getType() of type object<Railt\SDL\Contracts\Definitions\TypeDefinition> is not a sub-type of object<Railt\SDL\Contracts\Dependent\FieldDefinition>. It seems like you assume a child interface of the interface Railt\SDL\Contracts\Definitions\TypeDefinition to be always present.

                $router->route($event->getType())->then(\Closure::fromCallable([$controller, 'getDateTime']));

$event->getType() of type object<Railt\SDL\Contracts\Definitions\TypeDefinition> is not a sub-type of object<Railt\SDL\Contracts\Dependent\FieldDefinition>. It seems like you assume a child interface of the interface Railt\SDL\Contracts\Definitions\TypeDefinition to be always present.

            }
        };


        $listener->addListener(TypeBuilding::class, $invoke);
    }

    /**
     * @param TypeDefinition $type
     * @return bool
     */
    private function isCarbonField(TypeDefinition $type): bool
    {
        return $type instanceof FieldDefinition && $type->getTypeDefinition()->getName() === 'Carbon';
    }

    /**
     * @param Compiler $compiler
     * @param FieldDefinition|FieldBuilder|TypeDefinition $field
     */
    private function extend(Compiler $compiler, FieldDefinition $field): void
    {
        (function () use ($field, $compiler): void {
            $this->arguments[FormatArgument::ARGUMENT_NAME] = new FormatArgument($field, $compiler);

The property arguments does not exist. Did you maybe forget to declare it?

        })->call($field);
    }
}