Sarala\Query\QueryBuilderAbstract

Complexity

Total Complexity

25

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Importance

Changes	1
Bugs	1	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	appendParamsToPaginatedUrl()	0	21	4
A	fields()	0	2	1
A	__construct()	0	8	1
A	exact()	0	3	1
A	fetchFirst()	0	3	1
A	filter()	0	2	1
A	appendSortQuery()	0	7	2
A	getInitialQuery()	0	10	4
A	countExact()	0	3	1
A	include()	0	2	1
A	countAlias()	0	3	1
A	alias()	0	3	1
A	sort()	0	3	1
A	fetch()	0	21	5

<?php

declare(strict_types=1);

namespace Sarala\Query;

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

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

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

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

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

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

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

    public function __construct(Request $request)
    {
        $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 Illuminate\Database\Eloquent\Relations\Relation or Illuminate\Database\Query\Builder. However, the property $query is declared as type 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());
            }
        });
    }

    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);

        $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'));
        }

        return $paginator;
    }

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

    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.'
        );
    }
}