Sarala\Query\QueryBuilderAbstract

Complexity

Total Complexity

25

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
	init()	0	1	?
A	fields()	0	4	1
A	filter()	0	4	1
A	include()	0	4	1
A	sort()	0	4	1
A	exact()	0	4	1
A	countExact()	0	4	1
A	alias()	0	4	1
A	countAlias()	0	4	1
A	fetch()	0	22	5
A	appendSortQuery()	0	10	2
A	appendParamsToPaginatedUrl()	0	22	4
A	fetchFirst()	0	4	1
A	getInitialQuery()	0	12	4

<?php

declare(strict_types=1);

namespace Sarala\Query;

use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Query\Builder as QueryBuilder;
use Illuminate\Http\Request;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Contracts\Pagination\LengthAwarePaginator;

abstract class QueryBuilderAbstract
{
    /** @var Request $request */
    protected $request;

    /** @var Builder $query */
    protected $query;

    /** @var Fields $fields */
    protected $fields;

    /** @var QueryParamBag $includes */
    protected $includes;

    /** @var QueryParamBag $filters */
    protected $filters;

    /** @var QueryHelper $queryHelper */
    private $queryHelper;

    public function __construct(Request $request)

You have injected the Request via parameter $request. This is generally not recommended as there might be multiple instances during a request cycle (f.e. when using sub-requests). Instead, it is recommended to inject the RequestStack and retrieve the current request each time you need it via getCurrentRequest().

    {
        $this->request = $request;
        $this->fields = $this->request->fields();
        $this->includes = $this->request->includes();
        $this->filters = $this->request->filters();
        $this->query = $this->getInitialQuery();

It seems like $this->getInitialQuery() can also be of type object<Illuminate\Database\Query\Builder> or object<Illuminate\Database\Eloquent\Relations\Relation>. However, the property $query is declared as type object<Illuminate\Database\Eloquent\Builder>. Maybe add an additional type check?

        $this->queryHelper = new QueryHelper($this->query, $this->includes);
    }

    abstract protected function init();

    protected function fields()
    {
        // ..
    }

    protected function filter(QueryParamBag $filters)

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

    {
        // ..
    }

    protected function include(QueryParamBag $includes)

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

    {
        // ..
    }

    protected function sort(): array
    {
        return [];
    }

    public function exact($fields): QueryHelper
    {
        return $this->queryHelper->exact($fields);
    }

    public function countExact($fields): QueryHelper
    {
        return $this->queryHelper->countExact($fields);
    }

    public function alias($fields, $value = null): QueryHelper
    {
        return $this->queryHelper->alias($fields, $value);
    }

    public function countAlias($fields, $value = null): QueryHelper
    {
        return $this->queryHelper->countAlias($fields, $value);
    }

    public function fetch()
    {
        $this->fields();

        if ($this->request->filled('filter')) {
            $this->filter($this->filters);
        }

        if ($this->request->filled('include')) {
            $this->include($this->includes);
        }

        if ($this->request->filled('sort')) {
            $this->appendSortQuery();
        }

        if ($this->request->filled('page')) {
            return $this->appendParamsToPaginatedUrl();
        }

        return $this->query->get();
    }

    private function appendSortQuery(): void
    {
        $allowedSorts = $this->sort();

        $this->request->sorts()->each(function (SortField $field) use ($allowedSorts) {
            if (in_array($field->getField(), $allowedSorts)) {
                $this->query->orderBy($field->getField(), $field->getDirection());

The method orderBy() does not exist on Illuminate\Database\Eloquent\Builder. Did you maybe mean enforceOrderBy()?

            }
        });
    }

    private function appendParamsToPaginatedUrl(): LengthAwarePaginator
    {
        $perPage = $this->request->input('page.size', 10);
        $page = $this->request->input('page.number', 1);
        $paginator = $this->query->paginate($perPage, ['*'], 'page[number]', $page);

It seems like $perPage defined by $this->request->input('page.size', 10) on line 121 can also be of type array or string; however, Illuminate\Database\Eloquent\Builder::paginate() does only seem to accept integer|null, maybe add an additional type check?

It seems like $page defined by $this->request->input('page.number', 1) on line 122 can also be of type array or string; however, Illuminate\Database\Eloquent\Builder::paginate() does only seem to accept integer|null, maybe add an additional type check?

        $paginator->appends($this->request->except('page'));

        foreach ($this->request->get('filter', []) as $key => $value) {
            if (is_null($value)) {
                $value = '';
            }

            $paginator->appends("filter[{$key}]", $value);
        }

        if (! is_null($this->request->input('page.size'))) {
            $paginator->appends('page[size]', $this->request->input('page.size'));

It seems like $this->request->input('page.size') targeting Illuminate\Http\Concerns\InteractsWithInput::input() can also be of type array; however, Illuminate\Contracts\Pagination\Paginator::appends() does only seem to accept string|null, maybe add an additional type check?

        }

        return $paginator;
    }

    public function fetchFirst()
    {
        return $this->fetch()->first();

The method first does only exist in Illuminate\Database\Eloquent\Collection, but not in Illuminate\Contracts\Pagination\LengthAwarePaginator.

    }

    private function getInitialQuery()
    {
        $query = $this->init();

        if ($query instanceof Builder || $query instanceof QueryBuilder || $query instanceof Relation) {
            return $query;
        }

        throw new \Exception(
            'Expected init() method to return '.Builder::class.', '.QueryBuilder::class.' or a '.Relation::class.'. '.gettype($query).' returned.'
        );
    }
}