Valkyrja\Http\Middleware\Cache\CacheResponseMiddleware

Complexity

Total Complexity

13

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	terminated()	0	9	1
A	getCachePathForRequest()	0	3	1
A	getTtl()	0	3	1
B	requestReceived()	0	47	8
A	getHashedPath()	0	3	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Valkyrja Framework package.
 *
 * (c) Melech Mizrachi <melechmizrachi@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Valkyrja\Http\Middleware\Cache;

use Override;

The type Override was not found. Maybe you did not declare it correctly or list all dependencies?

use Throwable;
use Valkyrja\Filesystem\Manager\Contract\FilesystemContract;
use Valkyrja\Filesystem\Manager\InMemoryFilesystem;
use Valkyrja\Http\Message\Enum\StatusCode;
use Valkyrja\Http\Message\Request\Contract\ServerRequestContract;
use Valkyrja\Http\Message\Response\Contract\ResponseContract;
use Valkyrja\Http\Middleware\Contract\RequestReceivedMiddlewareContract;
use Valkyrja\Http\Middleware\Contract\TerminatedMiddlewareContract;
use Valkyrja\Http\Middleware\Handler\Contract\RequestReceivedHandlerContract;
use Valkyrja\Http\Middleware\Handler\Contract\TerminatedHandlerContract;
use Valkyrja\Support\Directory\Directory;

The type Valkyrja\Support\Directory\Directory was not found. Maybe you did not declare it correctly or list all dependencies?

use Valkyrja\Support\Time\Time;
use Valkyrja\Throwable\Exception\RuntimeException;

use function base64_decode;
use function base64_encode;
use function md5;
use function serialize;
use function unserialize;

class CacheResponseMiddleware implements RequestReceivedMiddlewareContract, TerminatedMiddlewareContract
{
    public function __construct(
        protected FilesystemContract $filesystem = new InMemoryFilesystem(),
        protected bool $debug = false
    ) {
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function requestReceived(ServerRequestContract $request, RequestReceivedHandlerContract $handler): ServerRequestContract|ResponseContract
    {
        $filesystem = $this->filesystem;

        $filePath = $this->getCachePathForRequest($request);

        if (! $this->debug && $filesystem->exists($filePath)) {
            $timestamp = $filesystem->timestamp($filePath) ?? 0;

            if (Time::get() - $timestamp > $this->getTtl()) {
                $filesystem->delete($filePath);

                return $handler->requestReceived($request);
            }

            try {
                $cache        = $filesystem->read($filePath);
                $decodedCache = base64_decode($cache, true);

                if ($decodedCache === false) {
                    throw new RuntimeException('Failed to decode cache');
                }

                /** @var object $response */
                $response = unserialize(
                    $decodedCache,
                    [
                        'allowed_classes' => true,
                    ]
                );

                // Ensure a valid response before returning it
                if (
                    $response instanceof ResponseContract
                    && $response->getStatusCode()->value < StatusCode::INTERNAL_SERVER_ERROR->value
                ) {
                    return $response;
                }
            } catch (Throwable) {

Consider adding a comment why this CATCH block is empty.

            }

            // Remove the bad cache
            $filesystem->delete($filePath);
        }

        return $handler->requestReceived($request);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function terminated(ServerRequestContract $request, ResponseContract $response, TerminatedHandlerContract $handler): void
    {
        $this->filesystem->write(
            $this->getCachePathForRequest($request),
            base64_encode(serialize($response))
        );

        $handler->terminated($request, $response);
    }

    /**
     * Get the ttl.
     *
     * @return int
     */
    protected function getTtl(): int
    {
        return 1800;
    }

    /**
     * Get a hashed version of the request path.
     *
     * @param ServerRequestContract $request
     *
     * @return string
     */
    protected function getHashedPath(ServerRequestContract $request): string
    {
        return md5($request->getUri()->getPath());
    }

    /**
     * Get the cache path for a request.
     */
    protected function getCachePathForRequest(ServerRequestContract $request): string
    {
        return Directory::cachePath('response/' . $this->getHashedPath($request));
    }
}