Sarala\Query\QueryBuilderAbstract

Complexity

Total Complexity

17

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Importance

Changes

0

12 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	alias()	0	4	1
A	fetch()	0	22	5
A	appendSortQuery()	0	10	2
A	appendParamsToPaginatedUrl()	0	14	2
A	fetchFirst()	0	4	1

<?php

declare(strict_types=1);

namespace Sarala\Query;

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->init();
        $this->queryHelper = new QueryHelper($this->query, $this->includes);
    }

    abstract protected function init(): Builder;

    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 alias(string $name, $value): QueryHelper
    {
        return $this->queryHelper->alias($name, $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 109 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 110 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'));

        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.

    }
}