silviooosilva / CacheerPHP

src/CacheStore/ArrayCacheStore.php

Spacing +5 added lines, -5 removed lines

@@ -44,7 +44,7 @@ 
   * @param int|string $ttl
   * @return mixed
   */
-  public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
+  public function getCache(string $cacheKey, string $namespace = '', string | int $ttl = 3600)
   {
 
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
@@ -59,7 +59,7 @@ 
     $expirationTime = $cacheData['expirationTime'] ?? 0;
     $now = time();
 
-    if($expirationTime !== 0 && $now >= $expirationTime) {
+    if ($expirationTime !== 0 && $now >= $expirationTime) {
       list($np, $key) = explode(':', $arrayStoreKey);
       $this->clearCache($key, $np);
       $this->setMessage("cacheKey: {$key} has expired.", false);
@@ -79,7 +79,7 @@ 
   * @param int|string $ttl
   * @return bool
   */
-  public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', int|string $ttl = 3600)
+  public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', int | string $ttl = 3600)
   {
 
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
@@ -159,12 +159,12 @@ 
   * @param string $namespace
   * @return void
   */
-  public function renewCache(string $cacheKey, int|string $ttl = 3600, string $namespace = '')
+  public function renewCache(string $cacheKey, int | string $ttl = 3600, string $namespace = '')
   {
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
 
     if (isset($this->arrayStore[$arrayStoreKey])) {
-        $ttlSeconds = is_numeric($ttl) ? (int) $ttl : strtotime($ttl) - time();
+        $ttlSeconds = is_numeric($ttl) ? (int)$ttl : strtotime($ttl) - time();
         $this->arrayStore[$arrayStoreKey]['expirationTime'] = time() + $ttlSeconds;
         $this->setMessage("cacheKey: {$cacheKey} renewed successfully", true);
         $this->logger->debug("{$this->getMessage()} from array driver.");

Indentation +123 added lines, -123 removed lines

@@ -13,10 +13,10 @@ 
 class ArrayCacheStore implements CacheerInterface
 {
 
-  /**
-  * @param array $arrayStore
-  */
-  private array $arrayStore = [];
+    /**
+     * @param array $arrayStore
+     */
+    private array $arrayStore = [];
 
     /**
      * @param boolean
@@ -33,26 +33,26 @@ 
      */
     private $logger = null;
 
-  public function __construct(string $logPath)
-  {
+    public function __construct(string $logPath)
+    {
     $this->logger = new CacheLogger($logPath);
-  }
+    }
 
-  /**
-  * @param string $cacheKey
-  * @param string $namespace
-  * @param int|string $ttl
-  * @return mixed
-  */
-  public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
-  {
+    /**
+     * @param string $cacheKey
+     * @param string $namespace
+     * @param int|string $ttl
+     * @return mixed
+     */
+    public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
+    {
 
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
 
     if (!$this->has($cacheKey, $namespace)) {
-      $this->setMessage("cacheData not found, does not exists or expired", false);
-      $this->logger->debug("{$this->getMessage()} from array driver.");
-      return false;
+        $this->setMessage("cacheData not found, does not exists or expired", false);
+        $this->logger->debug("{$this->getMessage()} from array driver.");
+        return false;
     }
 
     $cacheData = $this->arrayStore[$arrayStoreKey];
@@ -60,102 +60,102 @@ 
     $now = time();
 
     if($expirationTime !== 0 && $now >= $expirationTime) {
-      list($np, $key) = explode(':', $arrayStoreKey);
-      $this->clearCache($key, $np);
-      $this->setMessage("cacheKey: {$key} has expired.", false);
-      $this->logger->debug("{$this->getMessage()} from array driver.");
-      return false;
+        list($np, $key) = explode(':', $arrayStoreKey);
+        $this->clearCache($key, $np);
+        $this->setMessage("cacheKey: {$key} has expired.", false);
+        $this->logger->debug("{$this->getMessage()} from array driver.");
+        return false;
     }
 
     $this->setMessage("Cache retrieved successfully", true);
     $this->logger->debug("{$this->getMessage()} from array driver.");
     return $this->serialize($cacheData['cacheData'], false);
-  }
-
-  /**
-  * @param string $cacheKey
-  * @param mixed $cacheData
-  * @param string $namespace
-  * @param int|string $ttl
-  * @return bool
-  */
-  public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', int|string $ttl = 3600)
-  {
+    }
+
+    /**
+     * @param string $cacheKey
+     * @param mixed $cacheData
+     * @param string $namespace
+     * @param int|string $ttl
+     * @return bool
+     */
+    public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', int|string $ttl = 3600)
+    {
 
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
 
     $this->arrayStore[$arrayStoreKey] = [
-      'cacheData' => serialize($cacheData),
-      'expirationTime' => time() + $ttl
+        'cacheData' => serialize($cacheData),
+        'expirationTime' => time() + $ttl
     ];
 
     $this->setMessage("Cache stored successfully", true);
     $this->logger->debug("{$this->getMessage()} from Array driver.");
     return true;
-  }
+    }
 
-  /**
-  * @param array $items
-  * @param string $namespace
-  * @param int $batchSize
-  * @return void
-  */
-  public function putMany(array $items, string $namespace = '', int $batchSize = 100)
-  {
+    /**
+     * @param array $items
+     * @param string $namespace
+     * @param int $batchSize
+     * @return void
+     */
+    public function putMany(array $items, string $namespace = '', int $batchSize = 100)
+    {
 
     $chunks = array_chunk($items, $batchSize, true);
 
     foreach ($chunks as $chunk) {
-      foreach ($chunk as $key => $data) {
-          $this->putCache($data['cacheKey'], $data['cacheData'], $namespace);
+        foreach ($chunk as $key => $data) {
+            $this->putCache($data['cacheKey'], $data['cacheData'], $namespace);
+        }
         }
-      }
     $this->setMessage("{$this->getMessage()}", $this->isSuccess());
     $this->logger->debug("{$this->getMessage()} from Array driver.");
-  }
-
-  /**
-  * @param string $cacheKey
-  * @param mixed  $cacheData
-  * @param string $namespace
-  * @return bool
-  */
-  public function appendCache(string $cacheKey, mixed $cacheData, string $namespace = '')
-  {
-      $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
-
-      if (!$this->has($cacheKey, $namespace)) {
-          $this->setMessage("cacheData can't be appended, because doesn't exist or expired", false);
-          $this->logger->debug("{$this->getMessage()} from array driver.");
-          return false;
-      }
-
-      $this->arrayStore[$arrayStoreKey]['cacheData'] = serialize($cacheData);
-      $this->setMessage("Cache appended successfully", true);
-      return true;
-  }
-
-
-
-  /**
-  * @param string $cacheKey
-  * @param string $namespace
-  * @return bool
-  */
-  public function has(string $cacheKey, string $namespace = '')
-  {
+    }
+
+    /**
+     * @param string $cacheKey
+     * @param mixed  $cacheData
+     * @param string $namespace
+     * @return bool
+     */
+    public function appendCache(string $cacheKey, mixed $cacheData, string $namespace = '')
+    {
+        $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
+
+        if (!$this->has($cacheKey, $namespace)) {
+            $this->setMessage("cacheData can't be appended, because doesn't exist or expired", false);
+            $this->logger->debug("{$this->getMessage()} from array driver.");
+            return false;
+        }
+
+        $this->arrayStore[$arrayStoreKey]['cacheData'] = serialize($cacheData);
+        $this->setMessage("Cache appended successfully", true);
+        return true;
+    }
+
+
+
+    /**
+     * @param string $cacheKey
+     * @param string $namespace
+     * @return bool
+     */
+    public function has(string $cacheKey, string $namespace = '')
+    {
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
     return isset($this->arrayStore[$arrayStoreKey]) && time() < $this->arrayStore[$arrayStoreKey]['expirationTime'];
-  }
-
-  /**
-  * @param string $cacheKey
-  * @param int|string $ttl
-  * @param string $namespace
-  * @return void
-  */
-  public function renewCache(string $cacheKey, int|string $ttl = 3600, string $namespace = '')
-  {
+    }
+
+    /**
+     * @param string $cacheKey
+     * @param int|string $ttl
+     * @param string $namespace
+     * @return void
+     */
+    public function renewCache(string $cacheKey, int|string $ttl = 3600, string $namespace = '')
+    {
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
 
     if (isset($this->arrayStore[$arrayStoreKey])) {
@@ -163,33 +163,33 @@ 
         $this->arrayStore[$arrayStoreKey]['expirationTime'] = time() + $ttlSeconds;
         $this->setMessage("cacheKey: {$cacheKey} renewed successfully", true);
         $this->logger->debug("{$this->getMessage()} from array driver.");
-      }
-  }
+        }
+    }
   
-  /**
-  * @param string $cacheKey
-  * @param string $namespace
-  * @return void
-  */
-  public function clearCache(string $cacheKey, string $namespace = '')
-  {
+    /**
+     * @param string $cacheKey
+     * @param string $namespace
+     * @return void
+     */
+    public function clearCache(string $cacheKey, string $namespace = '')
+    {
     $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
     unset($this->arrayStore[$arrayStoreKey]);
     $this->setMessage("Cache cleared successfully", true);
     $this->logger->debug("{$this->getMessage()} from array driver.");
 
-  }
+    }
 
-  /**
-  * @return void
-  */
-  public function flushCache()
-  {
+    /**
+     * @return void
+     */
+    public function flushCache()
+    {
     unset($this->arrayStore);
     $this->arrayStore = [];
     $this->setMessage("Cache flushed successfully", true);
     $this->logger->debug("{$this->getMessage()} from array driver.");
-  }
+    }
     
     /**
      * @param string  $message
@@ -219,24 +219,24 @@ 
         return $this->success;
     }
 
-  /**
-  * @param string $cacheKey
-  * @param string $namespace
-  * @return string
-  */
-  private function buildArrayKey(string $cacheKey, string $namespace = '')
-  {
+    /**
+     * @param string $cacheKey
+     * @param string $namespace
+     * @return string
+     */
+    private function buildArrayKey(string $cacheKey, string $namespace = '')
+    {
     return !empty($namespace) ? ($namespace . ':' . $cacheKey) : $cacheKey;
-  }
-
-  /**
-  * @param mixed $data
-  * @param bool $serialize
-  * @return mixed
-  */
-  private function serialize(mixed $data, bool $serialize = true)
-  {
+    }
+
+    /**
+     * @param mixed $data
+     * @param bool $serialize
+     * @return mixed
+     */
+    private function serialize(mixed $data, bool $serialize = true)
+    {
     return $serialize ? serialize($data) : unserialize($data);
-  }
+    }
 
 }

src/Utils/CacheDriver.php

Indentation +9 added lines, -9 removed lines

@@ -65,8 +65,8 @@ 
     }
 
     /**
-    * @return Cacheer
-    */
+     * @return Cacheer
+     */
     public function useArrayDriver()
     {
         $this->cacheer->cacheStore = new ArrayCacheStore($this->logPath);
@@ -92,14 +92,14 @@ 
     }
 
     /**
-    * @param mixed $dirName
-    * @return bool
-    */
+     * @param mixed $dirName
+     * @return bool
+     */
     private function isDir(mixed $dirName)
     {
-      if (is_dir($dirName)) {
-          return true;
-      }
-      return mkdir($dirName, 0755, true);
+        if (is_dir($dirName)) {
+            return true;
+        }
+        return mkdir($dirName, 0755, true);
     }
 }

tests/Unit/ArrayCacheStoreTest.php

Spacing +4 added lines, -4 removed lines

@@ -258,13 +258,13 @@ 
     {
         $this->cache->flushCache();
 
-        $value = $this->cache->remember('remember_test_key', 60, function () {
+        $value = $this->cache->remember('remember_test_key', 60, function() {
             return 'valor_teste';
         });
 
         $this->assertEquals('valor_teste', $value);
 
-        $cachedValue = $this->cache->remember('remember_test_key', 60, function (){
+        $cachedValue = $this->cache->remember('remember_test_key', 60, function() {
             return 'novo_valor';
         });
 
@@ -276,12 +276,12 @@ 
     {
         $this->cache->flushCache();
 
-        $value = $this->cache->rememberForever('remember_forever_key', function () {
+        $value = $this->cache->rememberForever('remember_forever_key', function() {
             return 'valor_eterno';
         });
         $this->assertEquals('valor_eterno', $value);
 
-        $cachedValue = $this->cache->rememberForever('remember_forever_key', function () {
+        $cachedValue = $this->cache->rememberForever('remember_forever_key', function() {
             return 'novo_valor';
         });
 

Indentation +40 added lines, -40 removed lines

@@ -7,40 +7,40 @@ 
 class ArrayCacheStoreTest extends TestCase
 {
 
-  private $cache;
+    private $cache;
 
-  protected function setUp(): void
-  {
+    protected function setUp(): void
+    {
     $this->cache = new Cacheer();
     $this->cache->setDriver()->useArrayDriver();
     $this->cache->setConfig()->setTimeZone('America/Toronto');
-  }
+    }
 
-  protected function tearDown(): void
-  {
+    protected function tearDown(): void
+    {
     $this->cache->flushCache();
-  }
+    }
 
     public function testUsingArrayDriverSetsProperInstance()
-  {
+    {
     $this->assertInstanceOf(ArrayCacheStore::class, $this->cache->cacheStore);
-  }
+    }
 
-  public function testPutAndGetCacheInArray()
-  {
-      $cacheKey = 'test_key';
-      $cacheData = ['name' => 'John Doe', 'email' => 'john@example.com'];
+    public function testPutAndGetCacheInArray()
+    {
+        $cacheKey = 'test_key';
+        $cacheData = ['name' => 'John Doe', 'email' => 'john@example.com'];
       
-      $this->cache->putCache($cacheKey, $cacheData, '', 3600);
+        $this->cache->putCache($cacheKey, $cacheData, '', 3600);
 
-      $result = $this->cache->getCache($cacheKey);
+        $result = $this->cache->getCache($cacheKey);
 
-      $this->assertNotEmpty($result);
-      $this->assertEquals($cacheData, $result);
-  }
+        $this->assertNotEmpty($result);
+        $this->assertEquals($cacheData, $result);
+    }
 
-  public function testExpiredCacheInArray()
-  {
+    public function testExpiredCacheInArray()
+    {
     $cacheKey = 'expired_key';
     $cacheData = ['name' => 'Expired User', 'email' => 'expired@example.com'];
 
@@ -50,11 +50,11 @@ 
     $this->assertEquals("Cache stored successfully", $this->cache->getMessage());
     $this->assertEmpty($this->cache->getCache($cacheKey));
     $this->assertFalse($this->cache->isSuccess());
-  }
+    }
 
 
-  public function testOverwriteExistingCacheInArray()
-  {
+    public function testOverwriteExistingCacheInArray()
+    {
     $cacheKey = 'overwrite_key';
     $initialCacheData = ['name' => 'Initial Data', 'email' => 'initial@example.com'];
     $newCacheData = ['name' => 'New Data', 'email' => 'new@example.com'];
@@ -65,12 +65,12 @@ 
     $this->cache->appendCache($cacheKey, $newCacheData);
     $this->assertEquals("Cache appended successfully", $this->cache->getMessage());
     $this->assertEquals($newCacheData, $this->cache->getCache($cacheKey));
-  }
+    }
 
 
-  public function testPutManyCacheItemsInArray()
-  {
-     $items = [
+    public function testPutManyCacheItemsInArray()
+    {
+        $items = [
             [
                 'cacheKey' => 'user_1_profile',
                 'cacheData' => [
@@ -96,10 +96,10 @@ 
           
             $this->assertEquals($item['cacheData'], $this->cache->getCache($item['cacheKey']));
         }
-  }
+    }
 
-  public function testHasCacheFromArray()
-  {
+    public function testHasCacheFromArray()
+    {
     $cacheKey = 'test_key';
     $cacheData = ['name' => 'Sílvio Silva', 'role' => 'Developer'];
 
@@ -110,10 +110,10 @@ 
 
     $this->cache->has($cacheKey);
     $this->assertTrue($this->cache->isSuccess());
-  }
+    }
 
     public function testRenewCacheFromArray()
-  {
+    {
     $cacheKey = 'expired_key';
     $cacheData = ['name' => 'Expired User', 'email' => 'expired@example.com'];
 
@@ -128,10 +128,10 @@ 
     $this->cache->renewCache($cacheKey, 7200);
     $this->assertTrue($this->cache->isSuccess());
     $this->assertNotEmpty($this->cache->getCache($cacheKey));
-  }
+    }
 
-      public function testRenewCacheWithNamespaceFromArray()
-  {
+        public function testRenewCacheWithNamespaceFromArray()
+    {
     $cacheKey = 'expired_key';
     $namespace = 'expired_namespace';
     $cacheData = ['name' => 'Expired User', 'email' => 'expired@example.com'];
@@ -145,7 +145,7 @@ 
     $this->cache->renewCache($cacheKey, 7200, $namespace);
     $this->assertTrue($this->cache->isSuccess());
     $this->assertNotEmpty($this->cache->getCache($cacheKey, $namespace));
-  }
+    }
 
     public function testClearCacheDataFromArray()
     {
@@ -181,7 +181,7 @@ 
         $this->assertEquals("Cache flushed successfully", $this->cache->getMessage());
     }
 
-  public function test_remember_saves_and_recover_values() 
+    public function test_remember_saves_and_recover_values() 
     {
         $this->cache->flushCache();
 
@@ -216,7 +216,7 @@ 
     }
 
 
-      public function test_get_and_forget()
+        public function test_get_and_forget()
     {
         $cacheKey = 'cache_key_test';
         $this->cache->putCache($cacheKey, 10);
@@ -237,7 +237,7 @@ 
         $this->assertNull($noCacheData);
     }
 
-      public function test_store_if_not_present_with_add_function()
+        public function test_store_if_not_present_with_add_function()
     {
         $existentKey = 'cache_key_test';
 
@@ -261,7 +261,7 @@ 
 
     }
 
-      public function test_increment_function() {
+        public function test_increment_function() {
 
         $cacheKey = 'test_increment';
         $cacheData = 2025;

src/Cacheer.php

Indentation +34 added lines, -34 removed lines

@@ -131,11 +131,11 @@ 
     }
 
     /**
-    * @param string $cacheKey
-    * @param int $amount
-    * @param string $namespace
-    * @return bool
-    */
+     * @param string $cacheKey
+     * @param int $amount
+     * @param string $namespace
+     * @return bool
+     */
     public function increment(string $cacheKey, int $amount = 1, string $namespace = '')
     {
         $cacheData = $this->getCache($cacheKey, $namespace);
@@ -150,20 +150,20 @@ 
     }
 
     /**
-    * @param string $cacheKey
-    * @param int $amount
-    * @param string $namespace
-    * @return bool
-    */
+     * @param string $cacheKey
+     * @param int $amount
+     * @param string $namespace
+     * @return bool
+     */
     public function decrement(string $cacheKey, int $amount = 1, string $namespace = '')
     {
-      return $this->increment($cacheKey, ($amount * -1), $namespace);
+        return $this->increment($cacheKey, ($amount * -1), $namespace);
     }
     /**
-    * @param string $cacheKey
-    * @param mixed $cacheData
-    * @return void
-    */
+     * @param string $cacheKey
+     * @param mixed $cacheData
+     * @return void
+     */
     public function forever(string $cacheKey, mixed $cacheData)
     {
         $this->putCache($cacheKey, $cacheData, ttl: 31536000 * 1000);
@@ -171,11 +171,11 @@ 
     }
 
     /**
-    * @param string $cacheKey
-    * @param int|string $ttl
-    * @param Closure $callback
-    * @return mixed
-    */
+     * @param string $cacheKey
+     * @param int|string $ttl
+     * @param Closure $callback
+     * @return mixed
+     */
     public function remember(string $cacheKey, int|string $ttl, Closure $callback)
     {
         $cachedData = $this->getCache($cacheKey, ttl: $ttl);
@@ -192,20 +192,20 @@ 
     }
 
     /**
-    * @param string $cacheKey
-    * @param Closure $callback
-    * @return mixed
-    */
+     * @param string $cacheKey
+     * @param Closure $callback
+     * @return mixed
+     */
     public function rememberForever(string $cacheKey, Closure $callback)
     {
         return $this->remember($cacheKey, 31536000 * 1000, $callback);
     }
 
     /**
-    * @param string $cacheKey
-    * @param string $namespace
-    * @return mixed
-    */
+     * @param string $cacheKey
+     * @param string $namespace
+     * @return mixed
+     */
     public function getAndForget(string $cacheKey, string $namespace = '')
     {
         $cachedData = $this->getCache($cacheKey, $namespace);
@@ -219,12 +219,12 @@ 
     }
 
     /**
-    * @param string $cacheKey
-    * @param mixed  $cacheData
-    * @param string $namespace
-    * @param int|string $ttl
-    * @return bool
-    */
+     * @param string $cacheKey
+     * @param mixed  $cacheData
+     * @param string $namespace
+     * @param int|string $ttl
+     * @return bool
+     */
     public function add(string $cacheKey, mixed $cacheData, string $namespace = '', int|string $ttl = 3600)
     {
         if (!empty($this->getCache($cacheKey, $namespace))) {

Spacing +7 added lines, -7 removed lines

@@ -57,7 +57,7 @@ 
      * @param string|int $ttl
      * @return CacheDataFormatter|mixed
      */
-    public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
+    public function getCache(string $cacheKey, string $namespace = '', string | int $ttl = 3600)
     {
         $cacheData = $this->cacheStore->getCache($cacheKey, $namespace, $ttl);
         $this->setMessage($this->cacheStore->getMessage(), $this->cacheStore->isSuccess());
@@ -71,7 +71,7 @@ 
      * @param string|int $ttl
      * @return void
      */
-    public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', string|int $ttl = 3600)
+    public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', string | int $ttl = 3600)
     {
         $this->cacheStore->putCache($cacheKey, $cacheData, $namespace, $ttl);
         $this->setMessage($this->cacheStore->getMessage(), $this->cacheStore->isSuccess());
@@ -117,7 +117,7 @@ 
      * @param string $namespace
      * @return mixed
      */
-    public function renewCache(string $cacheKey, string|int $ttl = 3600, string $namespace = '')
+    public function renewCache(string $cacheKey, string | int $ttl = 3600, string $namespace = '')
     {
         $renewedCache = $this->cacheStore->renewCache($cacheKey, $ttl, $namespace);
 
@@ -140,7 +140,7 @@ 
     {
         $cacheData = $this->getCache($cacheKey, $namespace);
 
-        if(!empty($cacheData) && is_numeric($cacheData)) {
+        if (!empty($cacheData) && is_numeric($cacheData)) {
             $this->putCache($cacheKey, (int)($cacheData + $amount), $namespace);
             $this->setMessage($this->getMessage(), $this->isSuccess());
             return true;
@@ -176,11 +176,11 @@ 
     * @param Closure $callback
     * @return mixed
     */
-    public function remember(string $cacheKey, int|string $ttl, Closure $callback)
+    public function remember(string $cacheKey, int | string $ttl, Closure $callback)
     {
         $cachedData = $this->getCache($cacheKey, ttl: $ttl);
 
-        if(!empty($cachedData)) {
+        if (!empty($cachedData)) {
             return $cachedData;
         }
 
@@ -225,7 +225,7 @@ 
     * @param int|string $ttl
     * @return bool
     */
-    public function add(string $cacheKey, mixed $cacheData, string $namespace = '', int|string $ttl = 3600)
+    public function add(string $cacheKey, mixed $cacheData, string $namespace = '', int | string $ttl = 3600)
     {
         if (!empty($this->getCache($cacheKey, $namespace))) {
             return true;