Add support to persistent CachedConfig

Author: coisa

src/CachedConfig.php

@@ -16,6 +16,7 @@
 namespace FastForward\Config;
 
 use Psr\SimpleCache\CacheInterface;
+use Psr\SimpleCache\InvalidArgumentException;
 
 /**
  * Class CachedConfig.
@@ -36,25 +37,54 @@ final class CachedConfig implements ConfigInterface
      *
      * @param CacheInterface  $cache         the cache implementation used for storing configuration data
      * @param ConfigInterface $defaultConfig the configuration source to be cached
+     * @param bool            $persistent    whether the cache should be persistent or not
+     * @param string|null     $cacheKey      the cache key to use for storing the configuration data
      */
     public function __construct(
         private readonly CacheInterface $cache,
         private readonly ConfigInterface $defaultConfig,
-    ) {}
+        private readonly bool $persistent = false,
+        private ?string $cacheKey = null,
+    ) {
+        $this->cacheKey ??= $this->defaultConfig::class;
+    }
 
     /**
      * Invokes the configuration and returns the cached configuration data.
      *
      * If the configuration has not yet been cached, it MUST be stored in the cache upon first invocation.
+     * This method MUST return a ConfigInterface implementation containing the cached configuration data.
+     *
+     * @throws InvalidArgumentException if the cache key is invalid
      *
      * @return ConfigInterface a ConfigInterface implementation containing the cached configuration data
      */
     public function __invoke(): ConfigInterface
     {
-        if (!$this->cache->has($this->defaultConfig::class)) {
-            $this->cache->set($this->defaultConfig::class, $this->defaultConfig->toArray());
+        if (!$this->cache->has($this->cacheKey)) {
+            $this->cache->set($this->cacheKey, $this->defaultConfig->toArray());
         }
 
-        return new ArrayConfig($this->cache->get($this->defaultConfig::class));
+        return new ArrayConfig($this->cache->get($this->cacheKey));
+    }
+
+    /**
+     * Sets configuration data.
+     *
+     * This method MUST update the cached configuration data in the cache if the persistent flag is set to true.
+     *
+     * @param array|ConfigInterface|string $key   the configuration key or an array of key-value pairs to set
+     * @param mixed                        $value the value to set for the specified key
+     *
+     * @throws InvalidArgumentException if the key is invalid
+     */
+    public function set(array|ConfigInterface|string $key, mixed $value = null): void
+    {
+        $config = $this->getConfig();
+        $config->set($key, $value);
+
+        if ($this->persistent) {
+            $this->cache->set($this->cacheKey, $config->toArray());
+        }
     }
 }

src/Container/ConfigContainer.php

@@ -20,7 +20,7 @@
 use Psr\Container\ContainerInterface;
 
 /**
- * Class ConfigContainer
+ * Class ConfigContainer.
  *
  * Provides a PSR-11 compatible container interface for accessing configuration values.
  *
@@ -45,7 +45,7 @@ final class ConfigContainer implements ContainerInterface
      * This constructor SHALL wrap an existing ConfigInterface instance and expose it
      * through PSR-11 `get()` and `has()` methods with namespace-style key resolution.
      *
-     * @param ConfigInterface $config The configuration instance to expose as a container.
+     * @param ConfigInterface $config the configuration instance to expose as a container
      */
     public function __construct(
         private ConfigInterface $config,
@@ -58,8 +58,9 @@ public function __construct(
      * - The identifier matches known internal bindings (alias, interface, or class).
      * - The identifier is prefixed with 'config' and corresponds to an existing key in the configuration.
      *
-     * @param string $id Identifier of the entry to look for.
-     * @return bool True if the entry can be resolved; false otherwise.
+     * @param string $id identifier of the entry to look for
+     *
+     * @return bool true if the entry can be resolved; false otherwise
      */
     public function has(string $id): bool
     {
@@ -84,10 +85,11 @@ public function has(string $id): bool
      *   If the configuration key exists, its value SHALL be returned.
      * - If the identifier cannot be resolved, a ContainerNotFoundException MUST be thrown.
      *
-     * @param string $id Identifier of the entry to retrieve.
-     * @return mixed The value associated with the identifier.
+     * @param string $id identifier of the entry to retrieve
+     *
+     * @return mixed the value associated with the identifier
      *
-     * @throws ContainerNotFoundException If the identifier cannot be resolved.
+     * @throws ContainerNotFoundException if the identifier cannot be resolved
      */
     public function get(string $id)
     {
@@ -118,8 +120,9 @@ public function get(string $id)
      * - the ConfigInterface::class string
      * - the concrete class of the injected configuration instance
      *
-     * @param string $id The identifier to check.
-     * @return bool True if the identifier is resolved internally; false otherwise.
+     * @param string $id the identifier to check
+     *
+     * @return bool true if the identifier is resolved internally; false otherwise
      */
     private function isResolvedByContainer(string $id): bool
     {

tests/CachedConfigTest.php

@@ -2,17 +2,6 @@
 
 declare(strict_types=1);
 
-/**
- * This file is part of php-fast-forward/config.
- *
- * This source file is subject to the license bundled
- * with this source code in the file LICENSE.
- *
- * @link      https://github.com/php-fast-forward/config
- * @copyright Copyright (c) 2025 Felipe Sayão Lobato Abreu <github@mentordosnerds.com>
- * @license   https://opensource.org/licenses/MIT MIT License
- */
-
 namespace FastForward\Config\Tests;
 
 use FastForward\Config\ArrayConfig;
@@ -26,9 +15,6 @@
 use Prophecy\Prophecy\ObjectProphecy;
 use Psr\SimpleCache\CacheInterface;
 
-/**
- * @internal
- */
 #[CoversClass(CachedConfig::class)]
 #[UsesClass(ArrayConfig::class)]
 final class CachedConfigTest extends TestCase
@@ -49,6 +35,7 @@ protected function setUp(): void
         $this->cachedConfig = new CachedConfig(
             cache: $this->cache->reveal(),
             defaultConfig: $this->defaultConfig->reveal(),
+            persistent: true
         );
     }
 
@@ -82,4 +69,41 @@ public function testInvokeWillReturnCachedConfigInstanceWhenAlreadyCached(): voi
         self::assertInstanceOf(ArrayConfig::class, $result);
         self::assertSame($data, $result->toArray());
     }
+
+    #[Test]
+    public function testSetWillUpdateCacheWhenPersistentIsTrue(): void
+    {
+        $key   = uniqid();
+        $value = uniqid();
+        $data  = [$key => $value];
+
+        $this->cache->has($this->defaultConfig->reveal()::class)->willReturn(true);
+        $this->cache->get($this->defaultConfig->reveal()::class)->willReturn([]);
+
+        $this->cache->set($this->defaultConfig->reveal()::class, $data)->shouldBeCalled();
+
+        $this->cachedConfig->set($key, $value);
+
+        self::assertSame($value, $this->cachedConfig->get($key));
+    }
+
+    #[Test]
+    public function testSetWillNotUpdateCacheWhenPersistentIsFalse(): void
+    {
+        $cachedConfig = new CachedConfig(
+            cache: $this->cache->reveal(),
+            defaultConfig: $this->defaultConfig->reveal(),
+            persistent: false
+        );
+
+        $key   = uniqid();
+        $value = uniqid();
+
+        $this->cache->has($this->defaultConfig->reveal()::class)->willReturn(true);
+        $this->cache->get($this->defaultConfig->reveal()::class)->willReturn([]);
+
+        $this->cache->set($this->defaultConfig->reveal()::class, [$key => $value])->shouldNotBeCalled();
+
+        $cachedConfig->set($key, $value);
+    }
 }

tests/Container/ConfigContainerTest.php

@@ -97,4 +97,13 @@ public function testGetThrowsExceptionForUnknownKey(): void
 
         $container->get(uniqid('unknown_', true));
     }
+
+    #[Test]
+    public function testGetWithConfigContainerWillReturnConfigContainer(): void
+    {
+        $config    = new ArrayConfig();
+        $container = new ConfigContainer($config);
+
+        self::assertSame($container, $container->get(ConfigContainer::class));
+    }
 }