Neurony\QueryCache\Traits\IsCacheable

Complexity

Total Complexity

10

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	bootIsCacheable()	0	10	1
A	getQueryCacheTag()	0	4	1
A	getDuplicateQueryCacheTag()	0	4	1
A	clearQueryCache()	0	4	1
B	newBaseQueryBuilder()	0	34	6

<?php

namespace Neurony\QueryCache\Traits;

use Illuminate\Database\Query\Builder;
use Neurony\QueryCache\Database\QueryCacheBuilder;

trait IsCacheable
{
    /**
     * Boot the model.
     *
     * @return void
     */
    public static function bootIsCacheable()
    {
        static::saved(function ($model) {
            $model->clearQueryCache();
        });

        static::deleted(function ($model) {
            $model->clearQueryCache();
        });
    }

    /**
     * @return string
     */
    public function getQueryCacheTag(): string
    {
        return app('cache.query')->getAllQueryCachePrefix().'.'.(string) $this->getTable();

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * @return string
     */
    public function getDuplicateQueryCacheTag(): string
    {
        return app('cache.query')->getDuplicateQueryCachePrefix().'.'.(string) $this->getTable();

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Flush the query cache from Redis only for the tag corresponding to the model instance.
     *
     * @return void
     */
    public function clearQueryCache(): void
    {
        app('cache.query')->clearQueryCache($this);
    }

    /**
     * Get a new query builder instance for the connection.
     *
     * @return Builder
     */
    protected function newBaseQueryBuilder(): Builder
    {
        $cacheAllQueriesForever = false;
        $cacheOnlyDuplicateQueriesOnce = false;

        $connection = $this->getConnection();

It seems like getConnection() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $grammar = $connection->getQueryGrammar();

        if (app('cache.query')->canCacheQueries()) {
            if (app('cache.query')->shouldCacheAllQueries()) {
                $cacheAllQueriesForever = true;
            }

            if (app('cache.query')->shouldCacheDuplicateQueries()) {
                $cacheOnlyDuplicateQueriesOnce = true;
            }
        }

        if ($cacheAllQueriesForever === true) {
            return new QueryCacheBuilder(
                $connection, $grammar, $connection->getPostProcessor(),
                $this->getQueryCacheTag(), app('cache.query')->cacheAllQueriesForeverType()
            );
        }

        if ($cacheOnlyDuplicateQueriesOnce === true) {
            return new QueryCacheBuilder(
                $connection, $grammar, $connection->getPostProcessor(),
                $this->getDuplicateQueryCacheTag(), app('cache.query')->cacheOnlyDuplicateQueriesOnceType()
            );
        }

        return parent::newBaseQueryBuilder();
    }
}