BEAR\QueryRepository\QueryRepository

Complexity

Total Complexity

17

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getExpiryTime()	0	11	4
A	put()	0	21	4
A	__construct()	0	7	1
A	purge()	0	6	1
A	get()	0	12	2
A	getCacheableAnnotation()	0	3	1
A	getExpiryAtSec()	0	12	3
A	getHttpCacheAnnotation()	0	3	1

<?php

declare(strict_types=1);

namespace BEAR\QueryRepository;

use BEAR\QueryRepository\Exception\ExpireAtKeyNotExists;
use BEAR\RepositoryModule\Annotation\Cacheable;
use BEAR\RepositoryModule\Annotation\HttpCache;

This use statement conflicts with another class in this namespace, BEAR\QueryRepository\HttpCache. Consider defining an alias.

use BEAR\Resource\AbstractUri;
use BEAR\Resource\ResourceObject;
use Doctrine\Common\Annotations\Reader;
use Override;
use ReflectionClass;

use function is_array;
use function sprintf;
use function strtotime;
use function time;

final class QueryRepository implements QueryRepositoryInterface
{
    public function __construct(
        private readonly RepositoryLoggerInterface $logger,
        private readonly HeaderSetter $headerSetter,
        private readonly ResourceStorageInterface $storage,
        private readonly Reader $reader,
        private readonly Expiry $expiry,

The type BEAR\QueryRepository\Expiry was not found. Maybe you did not declare it correctly or list all dependencies?

    ) {
    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function put(ResourceObject $ro)
    {
        $this->logger->log('put-query-repository uri:%s', $ro->uri);
        $this->storage->deleteEtag($ro->uri);
        $ro->toString();
        $cacheable = $this->getCacheableAnnotation($ro);
        $httpCache = $this->getHttpCacheAnnotation($ro);
        $ttl = $this->getExpiryTime($ro, $cacheable);
        ($this->headerSetter)($ro, $ttl, $httpCache);
        if (isset($ro->headers[Header::ETAG])) {
            $etag = $ro->headers[Header::ETAG];
            $surrogateKeys = $ro->headers[Header::SURROGATE_KEY] ?? '';
            $this->storage->saveEtag($ro->uri, $etag, $surrogateKeys, $ttl);
        }

        if ($cacheable instanceof Cacheable && $cacheable->type === 'view') {
            return $this->storage->saveView($ro, $ttl);
        }

        return $this->storage->saveValue($ro, $ttl);
    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function get(AbstractUri $uri): ResourceState|null
    {
        $state = $this->storage->get($uri);

        if (! $state instanceof ResourceState) {
            return null;
        }

        $state->headers[Header::AGE] = (string) (time() - (int) strtotime($state->headers[Header::LAST_MODIFIED]));

        return $state;
    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function purge(AbstractUri $uri)
    {
        $this->logger->log('purge-query-repository uri:%s', $uri);

        return $this->storage->deleteEtag($uri);
    }

    private function getHttpCacheAnnotation(ResourceObject $ro): HttpCache|null
    {
        return $this->reader->getClassAnnotation(new ReflectionClass($ro), HttpCache::class);
    }

    private function getCacheableAnnotation(ResourceObject $ro): Cacheable|null
    {
        return $this->reader->getClassAnnotation(new ReflectionClass($ro), Cacheable::class);
    }

    private function getExpiryTime(ResourceObject $ro, Cacheable|null $cacheable = null): int
    {
        if ($cacheable === null) {
            return 0;
        }

        if ($cacheable->expiryAt !== '') {
            return $this->getExpiryAtSec($ro, $cacheable);
        }

        return $cacheable->expirySecond ?: $this->expiry->getTime($cacheable->expiry);
    }

    private function getExpiryAtSec(ResourceObject $ro, Cacheable $cacheable): int
    {
        if (! is_array($ro->body) || ! isset($ro->body[$cacheable->expiryAt])) {
            $msg = sprintf('%s::%s', $ro::class, $cacheable->expiryAt);

            throw new ExpireAtKeyNotExists($msg);
        }

        /** @var string $expiryAt */
        $expiryAt = $ro->body[$cacheable->expiryAt];

        return (int) strtotime($expiryAt) - time();
    }
}