SilverStripe\AssetAdmin\GraphQL\ReadFileQueryCreator

Complexity

Total Complexity

12

Size/Duplication

Total Lines	86
Duplicated Lines	10.47 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	attributes()	0	6	1
C	resolveConnection()	0	42	8
B	createConnection()	9	32	3

<?php
namespace SilverStripe\AssetAdmin\GraphQL;

use SilverStripe\Assets\File;
use SilverStripe\Assets\Folder;
use GraphQL\Type\Definition\UnionType;
use SilverStripe\GraphQL\Pagination\PaginatedQueryCreator;
use SilverStripe\GraphQL\Pagination\Connection;
use SilverStripe\ORM\Versioning\Versioned;

class ReadFileQueryCreator extends PaginatedQueryCreator

There is one abstract method connection in this class; you could implement it, or declare this class as abstract.

{

    public function attributes()
    {
        return [
            'name' => 'readFiles'
        ];
    }

    public function createConnection()
    {
        return Connection::create('readFiles')
            ->setConnectionType(function () {
                $unionType = new UnionType([
                    'name' => 'Result',
                    'types' => [
                        $this->manager->getType('File'),
                        $this->manager->getType('Folder')
                    ],
                    'resolveType' => function ($object) {

This code seems to be duplicated across your project.

                        if ($object instanceof Folder) {
                            return $this->manager->getType('Folder');
                        }
                        if ($object instanceof File) {
                            return $this->manager->getType('File');
                        }
                        return null;
                    }
                ]);
                return $unionType;
            })
            ->setArgs(function () {
                return [
                    'filter' => [
                        'type' => $this->manager->getType('FileFilterInput')
                    ]
                ];
            })
            ->setSortableFields(['ID', 'Title', 'Created', 'LastEdited'])
            ->setConnectionResolver(array($this, 'resolveConnection'));
    }

    public function resolveConnection($object, array $args, $context, $info)

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

    {
        $filter = (!empty($args['filter'])) ? $args['filter'] : [];

        // Permission checks
        $parent = Folder::singleton();
        if (isset($filter['parentId']) && $filter['parentId'] !== 0) {
            $parent = Folder::get()->byID($filter['parentId']);
            if (!$parent) {
                throw new \InvalidArgumentException(sprintf(
                    '%s#%s not found',
                    Folder::class,
                    $filter['parentId']
                ));
            }
        }
        if (!$parent->canView($context['currentUser'])) {
            throw new \InvalidArgumentException(sprintf(
                '%s#%s view access not permitted',
                Folder::class,
                $parent->ID
            ));
        }

        if (isset($filter['recursive']) && $filter['recursive']) {
            throw new \InvalidArgumentException((
               'The "recursive" flag can only be used for the "children" field'
            ));
        }

        // Filter list
        $list = Versioned::get_by_stage(File::class, Versioned::DRAFT);
        $filterInputType = new FileFilterInputTypeCreator($this->manager);
        $list = $filterInputType->filterList($list, $filter);

        // Permission checks
        $list = $list->filterByCallback(function (File $file) use ($context) {
            return $file->canView($context['currentUser']);
        });

        return $list;
    }
}