BEAR\QueryRepository\DonutRepository

Complexity

Total Complexity

14

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	invalidateTags()	0	3	1
A	purge()	0	3	1
A	putStatic()	0	15	1
A	__construct()	0	16	1
A	getHeaderKeys()	0	3	2
A	saveView()	0	7	1
A	refreshDonut()	0	22	3
A	setHeaders()	0	5	1
A	putDonut()	0	14	1
A	get()	0	13	2

<?php

declare(strict_types=1);

namespace BEAR\QueryRepository;

use BEAR\Resource\AbstractUri;
use BEAR\Resource\ResourceInterface;
use BEAR\Resource\ResourceObject;

use function assert;
use function explode;

final class DonutRepository implements DonutRepositoryInterface
{
    private ResourceStorageInterface $resourceStorage;
    private HeaderSetter $headerSetter;
    private ResourceInterface $resource;
    private QueryRepository $queryRepository;
    private CdnCacheControlHeaderSetterInterface $cdnCacheControlHeaderSetter;
    private RepositoryLoggerInterface $logger;
    private DonutRenderer $renderer;

    public function __construct(
        QueryRepository $queryRepository,
        HeaderSetter $headerSetter,
        ResourceStorageInterface $resourceStorage,
        ResourceInterface $resource,
        CdnCacheControlHeaderSetterInterface $cdnCacheControlHeaderSetter,
        RepositoryLoggerInterface $logger,
        DonutRenderer $renderer
    ) {
        $this->resourceStorage = $resourceStorage;
        $this->headerSetter = $headerSetter;
        $this->resource = $resource;
        $this->queryRepository = $queryRepository;
        $this->cdnCacheControlHeaderSetter = $cdnCacheControlHeaderSetter;
        $this->logger = $logger;
        $this->renderer = $renderer;
    }

    public function get(ResourceObject $ro): ?ResourceObject
    {
        $maybeState = $this->queryRepository->get($ro->uri);
        $this->logger->log('try-donut-view: uri:%s', $ro->uri);
        if ($maybeState instanceof ResourceState) {
            $this->logger->log('found-donut-view: uri:%s', $ro->uri);
            $ro->headers = $maybeState->headers;
            $ro->view = $maybeState->view;

            return $ro;
        }

        return $this->refreshDonut($ro);
    }

    /**
     * {@inheritDoc}
     */
    public function putStatic(ResourceObject $ro, ?int $ttl = null, ?int $sMaxAge = null): ResourceObject
    {
        $this->logger->log('put-donut: uri:%s ttl:%s s-maxage:%d', (string) $ro->uri, $sMaxAge, $ttl);
        $keys = new SurrogateKeys($ro->uri);
        $headerKeys = $this->getHeaderKeys($ro);
        $donut = ResourceDonut::create($ro, $this->renderer, $keys, $sMaxAge, true);
        $donut->render($ro, $this->renderer);
        $this->setHeaders($keys, $ro, $sMaxAge);
        // delete
        $this->resourceStorage->invalidateTags([(new UriTag())($ro->uri)]);
        // save content cache and donut
        $this->saveView($ro, $sMaxAge);
        $this->resourceStorage->saveDonut($ro->uri, $donut, $ttl, $headerKeys);

        return $ro;
    }

    /**
     * {@inheritDoc}
     */
    public function putDonut(ResourceObject $ro, ?int $donutTtl): ResourceObject
    {
        $this->logger->log('put-donut: uri:%s ttl:%s', (string) $ro->uri, $donutTtl);
        $keys = new SurrogateKeys($ro->uri);
        $keyArrays = $this->getHeaderKeys($ro);
        $donut = ResourceDonut::create($ro, $this->renderer, $keys, $donutTtl, false);
        $donut->render($ro, $this->renderer);
        $keys->setSurrogateHeader($ro);
        // delete
        $this->resourceStorage->invalidateTags([(new UriTag())($ro->uri)]);
        // save donut
        $this->resourceStorage->saveDonut($ro->uri, $donut, $donutTtl, $keyArrays);

        return $ro;
    }

    /**
     * {@inheritDoc}
     */
    public function purge(AbstractUri $uri): void
    {
        $this->queryRepository->purge($uri);
    }

    /**
     * {@inheritDoc}
     */
    public function invalidateTags(array $tags): void
    {
        $this->resourceStorage->invalidateTags($tags);
    }

    private function refreshDonut(ResourceObject $ro): ?ResourceObject
    {
        $donut = $this->resourceStorage->getDonut($ro->uri);
        $this->logger->log('try-donut uri:%s', (string) $ro->uri);
        if (! $donut instanceof ResourceDonut) {
            $this->logger->log('no-donut-found uri:%s', (string) $ro->uri);

            return null;
        }

        $this->logger->log('refresh-donut: uri:%s', $ro->uri);
        $donut->refresh($this->resource, $ro);
        if (! $donut->isCacheble) {
            return $ro;
        }

        ($this->headerSetter)($ro, $donut->ttl, null);
        $ro->headers[Header::ETAG] .= 'r'; // mark refreshed by resource static
        ($this->cdnCacheControlHeaderSetter)($ro, $donut->ttl);
        $this->saveView($ro, $donut->ttl);

        return $ro;
    }

    private function saveView(ResourceObject $ro, ?int $ttl): bool
    {
        assert(isset($ro->headers[Header::ETAG]));
        $surrogateKeys = $ro->headers[Header::SURROGATE_KEY] ?? '';
        $this->resourceStorage->saveEtag($ro->uri, $ro->headers[Header::ETAG], $surrogateKeys, $ttl);

        return $this->resourceStorage->saveDonutView($ro, $ttl);
    }

    private function setHeaders(SurrogateKeys $keys, ResourceObject $ro, ?int $sMaxAge): void
    {
        $keys->setSurrogateHeader($ro);
        ($this->cdnCacheControlHeaderSetter)($ro, $sMaxAge);
        ($this->headerSetter)($ro, 0, null);
    }

    /**
     * @return list<string>

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

     */
    public function getHeaderKeys(ResourceObject $ro): array
    {
        return isset($ro->headers[Header::SURROGATE_KEY]) ? explode(' ', $ro->headers[Header::SURROGATE_KEY]) : [];

The expression return IssetNode ? explode(' ', $ro->headers[BEAR\QueryRepository\Header::SURROGATE_KEY]) : array() returns the type array|string[] which is incompatible with the documented return type BEAR\QueryRepository\list.

    }
}