- replaced

	$eagerLoad = $this->eagerLoad ?? [];
	$model = $this->model ?? $this;
	$query = $this->query ?? app(Builder::class);
  with
	$eagerLoad = $this->retrieveEagerLoad();
	$model = $this->retrieveCacheModel();
	$query = $this->retrieveCacheQuery();
  to avoid name collisions in case the model contains one of the 'eagerLoad', 'mode' or 'query' attributes

- added makeCachePrefix and used it to prefix cache tags and keyDifferentiator and class name tag with the value returned by the 'getCachePrefix' method of the model
  This method can be used in a multitenant implementation where an object with the same key and tags is cached for each tenant database connection.

- added CacheGlobal class to be a placeholder for the global static cache disable flag. The cached value using $cache might generate unpredictable behaviour in case multiple requests are made to the server in the same time.

Author: lucian-dragomir

src/Traits/Cachable.php

@@ -7,11 +7,13 @@
 use Illuminate\Database\Query\Builder;
 use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
 use GeneaLabs\LaravelModelCaching\CachedBuilder;
+use Illuminate\Database\Eloquent\Model;
+
+use GeneaLabs\LaravelModelCaching\CacheGlobal;
 
 trait Cachable
 {
     protected $isCachable = true;
-    protected static $isCachableKey = 'genealabs:model-caching:is-disabled';
 
     protected function cache(array $tags = [])
     {
@@ -22,8 +24,8 @@ protected function cache(array $tags = [])
         }
 
         if (is_subclass_of($cache->getStore(), TaggableStore::class)) {
-            if (is_a($this, CachedModel::class)) {
-                array_push($tags, str_slug(get_called_class()));
+            if (is_a($this, Model::class)) {
+                array_push($tags, $this->makeCachePrefix(str_slug(get_called_class())));
             }
 
             $cache = $cache->tags($tags);
@@ -34,7 +36,8 @@ protected function cache(array $tags = [])
 
     public function disableCache()
     {
-        cache()->forever(self::$isCachableKey, true);
+
+        CacheGlobal::disableCache();
 
         $this->isCachable = false;
 
@@ -50,24 +53,86 @@ public function flushCache(array $tags = [])
         $this->cache($tags)->flush();
     }
 
+    protected function retrieveEagerLoad()
+    {
+        if (is_a($this, Model::class)) {
+            return [];
+        }
+        if (is_a($this, EloquentBuilder::class)) {
+            return $this->eagerLoad ?? [];
+        }
+        return null;
+    }
+
+    protected function retrieveCacheModel()
+    {
+        if (is_a($this, Model::class)) {
+            return $this;
+        }
+        if (is_a($this, EloquentBuilder::class)) {
+            return $this->model;
+        }
+        return null;
+    }
+
+    protected function retrieveCacheQuery()
+    {
+        if (is_a($this, Model::class)) {
+            return app(Builder::class);
+        }
+        if (is_a($this, EloquentBuilder::class)) {
+            return $this->query;
+        }
+        return null;
+    }
+
+    protected function makeCachePrefix($elementMix)
+    {
+        $model = $this->retrieveCacheModel();
+        if (!method_exists($model, "getCachePrefix")) {
+            return $elementMix;
+        }
+
+        $result = null;
+        $cachePrefix = $model->getCachePrefix();
+        if ($cachePrefix == null) {
+            return $elementMix;
+        }
+        if (is_array($elementMix)) {
+            $result = [];
+            foreach ($elementMix as $value) {
+                array_push($result, $cachePrefix . '-' . $value);
+            }
+            return $result;
+        } else {
+            $result = $cachePrefix . '-' . $elementMix;
+        }
+        return $result;
+    }
+
     protected function makeCacheKey(
         array $columns = ['*'],
         $idColumn = null,
         string $keyDifferentiator = ''
     ) : string {
-        $eagerLoad = $this->eagerLoad ?? [];
-        $model = $this->model ?? $this;
-        $query = $this->query ?? app(Builder::class);
+        $eagerLoad = $this->retrieveEagerLoad();
+        $model = $this->retrieveCacheModel();
+        $query = $this->retrieveCacheQuery();
 
         return (new CacheKey($eagerLoad, $model, $query))
-            ->make($columns, $idColumn, $keyDifferentiator);
+            ->make($columns, $idColumn, $this->makeCachePrefix($keyDifferentiator));
     }
 
     protected function makeCacheTags() : array
     {
-        $tags = (new CacheTags($this->eagerLoad ?? [], $this->model ?? $this))
+        $eagerLoad = $this->retrieveEagerLoad();
+        $model = $this->retrieveCacheModel();
+
+        $tags = (new CacheTags($eagerLoad, $model))
             ->make();
 
+        $tags = $this->makeCachePrefix($tags);
+
         return $tags;
     }
 
@@ -80,7 +145,7 @@ public static function bootCachable()
 
     public static function all($columns = ['*'])
     {
-        if (cache()->get(self::$isCachableKey)) {
+        if (CacheGlobal::isDisabled()) {
             return parent::all($columns);
         }
 
@@ -97,8 +162,8 @@ public static function all($columns = ['*'])
 
     public function newEloquentBuilder($query)
     {
-        if (cache()->get(self::$isCachableKey)) {
-            cache()->forget(self::$isCachableKey);
+        if (CacheGlobal::isDisabled()) {
+            CacheGlobal::enableCache();
 
             return new EloquentBuilder($query);
         }