Added cache implementation for queries

composer.json

@@ -27,6 +27,7 @@
 		"kubawerlos/php-cs-fixer-custom-fixers": "^3.13",
 		"latte/latte": "^3.0",
 		"nette/application": "^3.1",
+		"nette/caching": "^3.2",
 		"nette/mail": "^3.1",
 		"nette/security": "^3.1",
 		"nette/tester": "^2.5",

src/ArchitectureBundle/Bridge/Nette/DI/definitions/architecture_bundle/infrastructure.cache.neon

@@ -0,0 +1,9 @@
+services:
+    infrastructure.cache:
+        autowired: SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\CacheInterface
+        type: SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\CacheInterface
+        factory: @extension.infrastructure.cache.nette
+
+    infrastructure.cache.nette:
+        autowired: no
+        factory: SixtyEightPublishers\ArchitectureBundle\Infrastructure\NetteCache\NetteCache

src/ArchitectureBundle/Bridge/Nette/DI/definitions/message_bus/query_bus.neon

@@ -4,4 +4,5 @@ middleware:
     - Symfony\Component\Messenger\Middleware\AddBusNameStampMiddleware(query_bus)
     - Symfony\Component\Messenger\Middleware\FailedMessageProcessingMiddleware
     - SixtyEightPublishers\ArchitectureBundle\Bridge\Symfony\Messenger\Middleware\OriginalExceptionMiddleware
+    - SixtyEightPublishers\ArchitectureBundle\Bridge\Symfony\Messenger\Middleware\QueryCacheMiddleware
 panel: %debugMode%

src/ArchitectureBundle/Bridge/Symfony/Messenger/Middleware/QueryCacheMiddleware.php

@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\ArchitectureBundle\Bridge\Symfony\Messenger\Middleware;
+
+use Psr\Log\LoggerInterface;
+use SixtyEightPublishers\ArchitectureBundle\Bridge\Symfony\Messenger\Stamp\RefreshCacheStamp;
+use SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\CacheInterface;
+use SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\UnableToReadCacheException;
+use SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\UnableToWriteCacheException;
+use SixtyEightPublishers\ArchitectureBundle\ReadModel\Query\CachableQueryInterface;
+use Symfony\Component\Messenger\Envelope;
+use Symfony\Component\Messenger\Middleware\MiddlewareInterface;
+use Symfony\Component\Messenger\Middleware\StackInterface;
+
+final class QueryCacheMiddleware implements MiddlewareInterface
+{
+    public function __construct(
+        private readonly CacheInterface $cache,
+        private readonly ?LoggerInterface $logger = null,
+    ) {}
+
+    public function handle(Envelope $envelope, StackInterface $stack): Envelope
+    {
+        $message = $envelope->getMessage();
+
+        if (!($message instanceof CachableQueryInterface)) {
+            return $stack->next()->handle(
+                envelope: $envelope,
+                stack: $stack,
+            );
+        }
+
+        $refreshCache = $envelope->last(RefreshCacheStamp::class) !== null;
+        $cacheMetadata = $message->createCacheMetadata();
+
+        try {
+            $item = !$refreshCache ? $this->cache->getItem(
+                key: $cacheMetadata->key,
+            ) : null;
+        } catch (UnableToReadCacheException $e) {
+            if (null === $this->logger) {
+                throw $e;
+            }
+
+            $this->logger->error(
+                message: $e->getMessage(),
+                context: [
+                    'exception' => $e,
+                ],
+            );
+
+            $item = null;
+        }
+
+        if (null !== $item) {
+            return $item;
+        }
+
+        $item = $stack->next()->handle(
+            envelope: $envelope,
+            stack: $stack,
+        );
+
+        try {
+            $this->cache->saveItem(
+                metadata: $cacheMetadata,
+                item: $item,
+            );
+        } catch (UnableToWriteCacheException $e) {
+            if (null === $this->logger) {
+                throw $e;
+            }
+
+            $this->logger->error(
+                message: $e->getMessage(),
+                context: [
+                    'exception' => $e,
+                ],
+            );
+        }
+
+        return $item;
+    }
+}

src/ArchitectureBundle/Bridge/Symfony/Messenger/Stamp/RefreshCacheStamp.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\ArchitectureBundle\Bridge\Symfony\Messenger\Stamp;
+
+use Symfony\Component\Messenger\Stamp\StampInterface;
+
+final class RefreshCacheStamp implements StampInterface
+{
+}

src/ArchitectureBundle/Infrastructure/Cache/CacheInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache;
+
+interface CacheInterface
+{
+    /**
+     * @throws UnableToReadCacheException
+     */
+    public function getItem(string $key): mixed;
+
+    /**
+     * @throws UnableToWriteCacheException
+     */
+    public function saveItem(CacheMetadata $metadata, mixed $item): void;
+
+    /**
+     * @throws UnableToDeleteCacheException
+     */
+    public function deleteItem(string $key): void;
+
+    /**
+     * @param array<int, string>|null $tags
+     *
+     * @throws UnableToDeleteCacheException
+     */
+    public function clean(?array $tags = null): void;
+}

src/ArchitectureBundle/Infrastructure/Cache/CacheMetadata.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache;
+
+use DateTimeImmutable;
+
+final class CacheMetadata
+{
+    /**
+     * @param array<int, string> $tags
+     */
+    public function __construct(
+        public readonly string $key,
+        public readonly int|DateTimeImmutable|null $expiration,
+        public readonly array $tags = [],
+    ) {}
+}

src/ArchitectureBundle/Infrastructure/Cache/UnableToDeleteCacheException.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache;
+
+use RuntimeException;
+
+final class UnableToDeleteCacheException extends RuntimeException
+{
+}

src/ArchitectureBundle/Infrastructure/Cache/UnableToReadCacheException.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache;
+
+use RuntimeException;
+
+final class UnableToReadCacheException extends RuntimeException
+{
+}

src/ArchitectureBundle/Infrastructure/Cache/UnableToWriteCacheException.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache;
+
+use RuntimeException;
+
+final class UnableToWriteCacheException extends RuntimeException
+{
+}

src/ArchitectureBundle/Infrastructure/Doctrine/PersistenceAdapter/DoctrinePersistenceAdapter.php

@@ -69,7 +69,7 @@ public function pingConnection(): void
 
         try {
             $connection->executeQuery($connection->getDatabasePlatform()->getDummySelectSQL());
-        } catch (DBALException $e) {
+        } catch (DbalException $e) {
             $connection->close();
             $connection->connect();
         }

src/ArchitectureBundle/Infrastructure/NetteCache/NetteCache.php

@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\ArchitectureBundle\Infrastructure\NetteCache;
+
+use DateTimeImmutable;
+use Nette\Caching\Cache;
+use Nette\Caching\Storage;
+use SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\CacheInterface;
+use SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\CacheMetadata;
+use SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\UnableToDeleteCacheException;
+use SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\UnableToReadCacheException;
+use SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\UnableToWriteCacheException;
+use Throwable;
+use function count;
+use function is_int;
+
+final class NetteCache implements CacheInterface
+{
+    private readonly Cache $cache;
+
+    public function __construct(
+        Storage $storage,
+    ) {
+        $this->cache = new Cache(
+            storage: $storage,
+            namespace: self::class,
+        );
+    }
+
+    public function getItem(string $key): mixed
+    {
+        try {
+            return $this->cache->load(
+                key: $key,
+            );
+        } catch (Throwable $e) {
+            throw new UnableToReadCacheException(
+                message: $e->getMessage(),
+                code: $e->getCode(),
+                previous: $e,
+            );
+        }
+    }
+
+    public function saveItem(CacheMetadata $metadata, mixed $item): void
+    {
+        $dependencies = [];
+
+        if ($metadata->expiration instanceof DateTimeImmutable) {
+            $dependencies[Cache::Expire] = $metadata->expiration->format('U.u');
+        } elseif (is_int($metadata->expiration)) {
+            $dependencies[Cache::Expire] = $metadata->expiration + time();
+        }
+
+        if (0 < count($metadata->tags)) {
+            $dependencies[Cache::Tags] = $metadata->tags;
+        }
+
+        try {
+            $this->cache->save(
+                key: $metadata->key,
+                data: $item,
+                dependencies: $dependencies,
+            );
+        } catch (Throwable $e) {
+            throw new UnableToWriteCacheException(
+                message: $e->getMessage(),
+                code: $e->getCode(),
+                previous: $e,
+            );
+        }
+    }
+
+    public function deleteItem(string $key): void
+    {
+        try {
+            $this->cache->remove(
+                key: $key,
+            );
+        } catch (Throwable $e) {
+            throw new UnableToDeleteCacheException(
+                message: $e->getMessage(),
+                code: $e->getCode(),
+                previous: $e,
+            );
+        }
+    }
+
+    public function clean(?array $tags = null): void
+    {
+        $conditions = null !== $tags
+            ? [
+                Cache::Tags => $tags,
+            ]
+            : [
+                Cache::All => true,
+            ];
+
+        try {
+            $this->cache->clean(
+                conditions: $conditions,
+            );
+        } catch (Throwable $e) {
+            throw new UnableToDeleteCacheException(
+                message: $e->getMessage(),
+                code: $e->getCode(),
+                previous: $e,
+            );
+        }
+    }
+}

src/ArchitectureBundle/ReadModel/Query/CachableQueryInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SixtyEightPublishers\ArchitectureBundle\ReadModel\Query;
+
+use SixtyEightPublishers\ArchitectureBundle\Infrastructure\Cache\CacheMetadata;
+
+interface CachableQueryInterface extends QueryInterface
+{
+    public function createCacheMetadata(): CacheMetadata;
+}