Conia\Http\Response

Complexity

Total Complexity

43

Size/Duplication

Total Lines	279
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	getStatusCode()	0	3	1
A	header()	0	5	1
A	hasHeader()	0	3	1
A	fromFactory()	0	3	1
A	removeHeader()	0	5	1
A	getHeader()	0	3	1
A	getReasonPhrase()	0	3	1
A	status()	0	9	2
A	getProtocolVersion()	0	3	1
A	wrap()	0	5	1
A	unwrap()	0	3	1
A	__construct()	0	4	1
A	protocolVersion()	0	5	1
A	headers()	0	3	1
A	html()	0	3	1
A	sendfile()	0	16	2
A	getBody()	0	3	1
A	write()	0	5	1
A	setStringBody()	0	18	3
A	redirect()	0	6	1
A	json()	0	13	2
A	validateFile()	0	4	2
A	body()	0	15	5
A	file()	0	27	2
A	download()	0	13	2
A	text()	0	3	1
A	withContentType()	0	15	2
A	setStreamBody()	0	5	1
A	setResourceBody()	0	9	2

<?php

declare(strict_types=1);

namespace Conia\Http;

use Conia\Http\Exception\FileNotFoundException;
use Conia\Http\Exception\RuntimeException;
use finfo;
use Psr\Http\Message\ResponseFactoryInterface as PsrResponseFactory;
use Psr\Http\Message\ResponseInterface as PsrResponse;
use Psr\Http\Message\StreamFactoryInterface as PsrStreamFactory;
use Psr\Http\Message\StreamInterface as PsrStream;
use Stringable;
use Traversable;

/** @psalm-api */
class Response
{
    public function __construct(
        protected PsrResponse $psrResponse,
        protected readonly PsrStreamFactory|null $streamFactory = null,
    ) {
    }

    public static function fromFactory(PsrResponseFactory $responseFactory, PsrStreamFactory $streamFactory): self
    {
        return new self($responseFactory->createResponse(), $streamFactory);
    }

    public function unwrap(): PsrResponse
    {
        return $this->psrResponse;
    }

    public function wrap(PsrResponse $response): static
    {
        $this->psrResponse = $response;

        return $this;
    }

    public function status(int $statusCode, ?string $reasonPhrase = null): static
    {
        if (empty($reasonPhrase)) {
            $this->psrResponse = $this->psrResponse->withStatus($statusCode);
        } else {
            $this->psrResponse = $this->psrResponse->withStatus($statusCode, $reasonPhrase);
        }

        return $this;
    }

    public function getStatusCode(): int
    {
        return $this->psrResponse->getStatusCode();
    }

    public function getReasonPhrase(): string
    {
        return $this->psrResponse->getReasonPhrase();
    }

    public function getProtocolVersion(): string
    {
        return $this->psrResponse->getProtocolVersion();
    }

    public function protocolVersion(string $protocol): static
    {
        $this->psrResponse = $this->psrResponse->withProtocolVersion($protocol);

        return $this;
    }

    public function header(string $name, string $value): static
    {
        $this->psrResponse = $this->psrResponse->withAddedHeader($name, $value);

        return $this;
    }

    public function removeHeader(string $name): static
    {
        $this->psrResponse = $this->psrResponse->withoutHeader($name);

        return $this;
    }

    public function headers(): array
    {
        return $this->psrResponse->getHeaders();
    }

    public function getHeader(string $name): array
    {
        return $this->psrResponse->getHeader($name);
    }

    public function hasHeader(string $name): bool
    {
        return $this->psrResponse->hasHeader($name);
    }

    public function body(mixed $body): static
    {
        if ($body instanceof PsrStream) {
            return $this->setStreamBody($body);
        }

        if (is_string($body) || $body instanceof Stringable) {
            return $this->setStringBody((string)$body);
        }

        if (is_resource($body)) {
            return $this->setResourceBody($body);
        }

        throw new RuntimeException('Only strings, Stringable or resources are allowed to create streams!');
    }

    protected function setStringBody(string $body): static
    {
        if ($this->streamFactory) {
            $this->psrResponse = $this->psrResponse->withBody($this->streamFactory->createStream($body));

            return $this;
        }

        $stream = $this->psrResponse->getBody();

        if ($stream->isWritable()) {
            $stream->rewind();
            $stream->write($body);

            return $this;
        }

        throw new RuntimeException('The response body is not writable!');
    }

    protected function setStreamBody(PsrStream $body): static
    {
        $this->psrResponse = $this->psrResponse->withBody($body);

        return $this;
    }

    /**
     * @param resource $body
     */
    protected function setResourceBody(mixed $body): static
    {
        if ($this->streamFactory) {
            $this->psrResponse = $this->psrResponse->withBody($this->streamFactory->createStreamFromResource($body));

            return $this;
        }

        throw new RuntimeException('No factory available to create stream from resource!');
    }

    public function getBody(): PsrStream
    {
        return $this->psrResponse->getBody();
    }

    public function write(string $content): static
    {
        $this->psrResponse->getBody()->write($content);

        return $this;
    }

    public function redirect(string $url, int $code = 302): static
    {
        $this->header('Location', $url);
        $this->status($code);

        return $this;
    }

    public function withContentType(
        string $contentType,
        mixed $body = null,
        int $code = 200,
        string $reasonPhrase = ''
    ): static {
        $this->psrResponse = $this->psrResponse
            ->withStatus($code, $reasonPhrase)
            ->withAddedHeader('Content-Type', $contentType);

        if ($body) {
            $this->body($body);
        }

        return $this;
    }

    /**
     * @param null|PsrStream|resource|string $body
     */
    public function html(mixed $body = null, int $code = 200, string $reasonPhrase = ''): static
    {
        return $this->withContentType('text/html', $body, $code, $reasonPhrase);
    }

    /**
     * @param null|PsrStream|resource|string $body
     */
    public function text(mixed $body = null, int $code = 200, string $reasonPhrase = ''): static
    {
        return $this->withContentType('text/plain', $body, $code, $reasonPhrase);
    }

    public function json(
        mixed $data,
        int $code = 200,
        string $reasonPhrase = '',
        int $flags = JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR,
    ): static {
        if ($data instanceof Traversable) {
            $body = json_encode(iterator_to_array($data), $flags);
        } else {
            $body = json_encode($data, $flags);
        }

        return $this->withContentType('application/json', $body, $code, $reasonPhrase);
    }

    public function file(
        string $file,
        int $code = 200,
        string $reasonPhrase = '',
    ): static {
        $this->validateFile($file);

        $finfo = new finfo(FILEINFO_MIME_TYPE);
        $contentType = $finfo->file($file);
        $finfo = new finfo(FILEINFO_MIME_ENCODING);
        $encoding = $finfo->file($file);
        assert(isset($this->streamFactory));
        $stream = $this->streamFactory->createStreamFromFile($file, 'rb');

The method createStreamFromFile() does not exist on null.

        $this->psrResponse = $this->psrResponse
            ->withStatus($code, $reasonPhrase)
            ->withAddedHeader('Content-Type', $contentType)
            ->withAddedHeader('Content-Transfer-Encoding', $encoding)
            ->withBody($stream);

        $size = $stream->getSize();

        if (!is_null($size)) {
            $this->psrResponse = $this->psrResponse->withAddedHeader('Content-Length', (string)$size);
        }

        return $this;
    }

    public function download(
        string $file,
        string $newName = '',
        int $code = 200,
        string $reasonPhrase = '',
    ): static {
        $response = $this->file($file, $code, $reasonPhrase);
        $response->header(
            'Content-Disposition',
            'attachment; filename="' . ($newName ?: basename($file)) . '"'
        );

        return $response;
    }

    public function sendfile(
        string $file,
        int $code = 200,
        string $reasonPhrase = '',
    ): static {
        $this->validateFile($file);
        $server = strtolower($_SERVER['SERVER_SOFTWARE'] ?? '');
        $this->psrResponse = $this->psrResponse->withStatus($code, $reasonPhrase);

        if (strpos($server, 'nginx') !== false) {
            $this->psrResponse = $this->psrResponse->withAddedHeader('X-Accel-Redirect', $file);
        } else {
            $this->psrResponse = $this->psrResponse->withAddedHeader('X-Sendfile', $file);
        }

        return $this;
    }

    protected function validateFile(string $file): void
    {
        if (!is_file($file)) {
            throw new FileNotFoundException('File not found: ' . $file);
        }
    }
}