GeneaLabs\LaravelModelCaching\CachedBuilder

Complexity

Total Complexity

43

Size/Duplication

Total Lines	255
Duplicated Lines	21.96 %

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	cache()	0	9	2
A	getQueryColumns()	0	7	3
A	getModelSlug()	0	3	1
A	getLimitClause()	0	7	2
A	getOffsetClause()	0	7	2
A	getIdColumn()	0	4	2
A	getCacheKey()	0	12	2
A	getCacheTags()	0	22	3
A	min()	5	5	1
A	pluck()	0	11	2
A	getMethodKey()	0	3	1
A	find()	5	5	1
A	getWithModels()	0	9	2
A	getOrderByClauses()	0	5	1
A	getTypeClause()	0	5	2
B	getWhereClauses()	0	23	4
A	avg()	5	5	1
A	max()	5	5	1
A	getValuesClause()	0	5	2
A	getWheres()	0	9	2
A	count()	5	5	1
A	getModelTag()	0	3	1
A	cursor()	0	5	1
A	sum()	5	5	1
A	get()	5	5	1
A	first()	5	5	1

<?php namespace GeneaLabs\LaravelModelCaching;

use Closure;
use Illuminate\Cache\TaggableStore;
use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
use Illuminate\Database\Eloquent\Relations\Pivot;
use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Relations\Relation;

class CachedBuilder extends EloquentBuilder
{
    protected function cache(array $tags = [])
    {
        $cache = cache();

        if (is_subclass_of($cache->getStore(), TaggableStore::class)) {
            $cache = $cache->tags($tags);
        }

        return $cache;
    }

    protected function getCacheKey(array $columns = ['*'], $idColumn = null) : string
    {
        $key = $this->getModelSlug();
        $key .= $this->getIdColumn($idColumn ?: '');
        $key .= $this->getQueryColumns($columns);
        $key .= $this->getWhereClauses();
        $key .= $this->getWithModels();
        $key .= $this->getOrderByClauses();
        $key .= $this->getOffsetClause();
        $key .= $this->getLimitClause();

        return $key;
    }

    protected function getIdColumn(string $idColumn) : string
    {

        return $idColumn ? "_{$idColumn}" : '';
    }

    protected function getLimitClause() : string
    {
        if (! $this->query->limit) {
            return '';
        }

        return "-limit_{$this->query->limit}";
    }

    protected function getModelSlug() : string
    {
        return str_slug(get_class($this->model));
    }

    protected function getOffsetClause() : string
    {
        if (! $this->query->offset) {
            return '';
        }

        return "-offset_{$this->query->offset}";
    }

    protected function getQueryColumns(array $columns) : string
    {
        if ($columns === ['*'] || $columns === []) {
            return '';
        }

        return '_' . implode('_', $columns);
    }

    protected function getWhereClauses(array $wheres = []) : string
    {
        return $this->getWheres($wheres)
            ->reduce(function ($carry, $where) {
                if (in_array($where['type'], ['Exists', 'Nested', 'NotExists'])) {
                    return '_' . strtolower($where['type']) . $this->getWhereClauses($where['query']->wheres);
                }

                if ($where['type'] === 'Column') {
                    return "_{$where['boolean']}_{$where['first']}_{$where['operator']}_{$where['second']}";
                }

                if ($where['type'] === 'raw') {
                    return "_{$where['boolean']}_" . str_slug($where['sql']);
                }

                $value = array_get($where, 'value');
                $value .= $this->getTypeClause($where);
                $value .= $this->getValuesClause($where);

                return "{$carry}-{$where['column']}_{$value}";
            })
            . '';
    }

    protected function getWithModels() : string
    {
        $eagerLoads = collect($this->eagerLoad);

        if ($eagerLoads->isEmpty()) {
            return '';
        }

        return '-' . implode('-', $eagerLoads->keys()->toArray());
    }

	protected function getOrderByClauses(){
        $orders = collect($this->query->orders);

        return $orders->reduce(function($carry, $order){
            return $carry . '_orderBy_' . $order['column'] . '_' . $order['direction'];
        });
    }

    protected function getMethodKey(string $postfix = null) : string
    {
        return str_slug(get_class($this->model)) . $postfix;
    }

    protected function getModelTag() : array
    {
        return [str_slug(get_class($this->model))];
    }

    protected function getCacheTags() : array
    {
        return collect($this->eagerLoad)->keys()
            ->map(function ($relationName) {
                $relation = collect(explode('.', $relationName))
                    ->reduce(function ($carry, $name) {
                        if (! $carry) {
                            $carry = $this->model;
                        }

                        if ($carry instanceof Relation) {
                            $carry = $carry->getQuery()->model;
                        }

                        return $carry->{$name}();
                    });

                return str_slug(get_class($relation->getQuery()->model));
            })
            ->prepend(str_slug(get_class($this->model)))
            ->values()
            ->toArray();
    }

    public function avg($column)
    {
        return $this->cache($this->getModelTag())
            ->rememberForever($this->getMethodKey("-avg_{$column}"), function () use ($column) {
                return parent::avg($column);
            });
    }

    public function count($columns = ['*'])
    {
        return $this->cache($this->getModelTag())
            ->rememberForever($this->getMethodKey("-count"), function () use ($columns) {
                return parent::count($columns);
            });
    }

    public function cursor()
    {
        return $this->cache($this->getModelTag())
            ->rememberForever($this->getMethodKey("-cursor"), function () {
                return collect(parent::cursor());
            });
    }

    /**
     * @SuppressWarnings(PHPMD.ShortVariable)
     */
    public function find($id, $columns = ['*'])
    {
        return $this->cache($this->getCacheTags())
            ->rememberForever($this->getCacheKey($columns, $id), function () use ($id, $columns) {
                return parent::find($id, $columns);
            });
    }

    public function first($columns = ['*'])
    {
        return $this->cache($this->getCacheTags())
            ->rememberForever($this->getCacheKey($columns) . '-first', function () use ($columns) {
                return parent::first($columns);
            });
    }

    public function get($columns = ['*'])
    {
        return $this->cache($this->getCacheTags())
            ->rememberForever($this->getCacheKey($columns), function () use ($columns) {
                return parent::get($columns);
            });
    }

    public function max($column)

This method seems to be duplicated in your project.

    {
        return $this->cache($this->getModelTag())
            ->rememberForever($this->getMethodKey("-max_{$column}"), function () use ($column) {
                return parent::max($column);
            });
    }

    public function min($column)
    {
        return $this->cache($this->getModelTag())
            ->rememberForever($this->getMethodKey("-min_{$column}"), function () use ($column) {
                return parent::min($column);
            });
    }

    public function pluck($column, $key = null)
    {
        $cacheKey = $this->getCacheKey([$column]) . "-pluck_{$column}";

        if ($key) {
            $cacheKey .= "_{$key}";
        }

        return $this->cache($this->getCacheTags())
            ->rememberForever($cacheKey, function () use ($column, $key) {
                return parent::pluck($column, $key);
            });
    }

    public function sum($column)
    {
        return $this->cache($this->getModelTag())
            ->rememberForever($this->getMethodKey("-sum_{$column}"), function () use ($column) {
                return parent::sum($column);
            });
    }

    protected function getTypeClause($where)
    {
        return in_array($where['type'], ['In', 'Null', 'NotNull'])
            ? strtolower($where['type'])
            : '';
    }

    protected function getValuesClause($where)
    {
        return is_array(array_get($where, 'values'))
            ? '_' . implode('_', $where['values'])
            : '';
    }

    protected function getWheres(array $wheres) : Collection
    {
        $wheres = collect($wheres);

        if ($wheres->isEmpty()) {
            $wheres = collect($this->query->wheres);
        }

        return $wheres;
    }
}