Valkyrja\Http\Message\Request\ServerRequest

Complexity

Total Complexity

39

Size/Duplication

Total Lines	405
Duplicated Lines	0 %

Importance

Changes

0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	exceptAttributes()	0	4	1
A	getCookieParam()	0	4	1
A	hasQueryParam()	0	5	2
A	hasParsedBodyParam()	0	5	2
A	withAttribute()	0	8	1
A	getParsedBodyParam()	0	4	1
A	getQueryParam()	0	4	1
A	exceptQueryParams()	0	4	1
A	getAttribute()	0	4	1
A	isXmlHttpRequest()	0	4	1
A	exceptParsedBody()	0	4	1
A	onlyParams()	0	6	1
A	withCookieParams()	0	8	1
A	getAttributes()	0	4	1
A	hasCookieParam()	0	5	2
A	withAddedParsedBodyParam()	0	8	1
A	exceptParams()	0	6	1
A	withAddedCookieParam()	0	8	1
A	getServerParam()	0	4	1
A	withAddedUploadedFile()	0	8	1
A	withAddedQueryParam()	0	8	1
A	getServerParams()	0	4	1
A	getQueryParams()	0	4	1
A	onlyAttributes()	0	4	1
A	onlyParsedBody()	0	4	1
A	withoutAttribute()	0	8	1
A	getParsedBody()	0	4	1
A	__construct()	0	15	1
A	withParsedBody()	0	8	1
A	getCookieParams()	0	4	1
A	hasServerParam()	0	5	2
A	withUploadedFiles()	0	8	1
A	onlyQueryParams()	0	4	1
A	getUploadedFiles()	0	4	1
A	withQueryParams()	0	8	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\Message\Request;

use Override;

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

use Valkyrja\Http\Message\Constant\HeaderName;

The type Valkyrja\Http\Message\Constant\HeaderName was not found. Maybe you did not declare it correctly or list all dependencies?

use Valkyrja\Http\Message\Enum\ProtocolVersion;
use Valkyrja\Http\Message\Enum\RequestMethod;

The type Valkyrja\Http\Message\Enum\RequestMethod was not found. Maybe you did not declare it correctly or list all dependencies?

use Valkyrja\Http\Message\Exception\InvalidArgumentException;
use Valkyrja\Http\Message\File\Contract\UploadedFile;
use Valkyrja\Http\Message\Request\Contract\ServerRequest as Contract;
use Valkyrja\Http\Message\Stream\Contract\Stream;
use Valkyrja\Http\Message\Stream\Enum\PhpWrapper;
use Valkyrja\Http\Message\Stream\Stream as HttpStream;
use Valkyrja\Http\Message\Uri\Contract\Uri;
use Valkyrja\Http\Message\Uri\Uri as HttpUri;

use function array_filter;
use function array_key_exists;
use function in_array;

use const ARRAY_FILTER_USE_KEY;

/**
 * Class ServerRequest.
 *
 * @author Melech Mizrachi
 */
class ServerRequest extends Request implements Contract
{
    /**
     * The attributes.
     *
     * @var array<string, mixed>
     */
    protected array $attributes = [];

    /**
     * ServerRequest constructor.
     *
     * @param Uri                        $uri        [optional] The uri
     * @param RequestMethod              $method     [optional] The method
     * @param Stream                     $body       [optional] The body stream
     * @param array<string, string[]>    $headers    [optional] The headers
     * @param array<string, mixed>       $server     [optional] The server
     * @param array<string, string|null> $cookies    [optional] The cookies
     * @param array<array-key, mixed>    $query      [optional] The query string

The doc comment array<array-key, mixed> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, mixed>.

     * @param array<array-key, mixed>    $parsedBody [optional] The parsed body
     * @param ProtocolVersion            $protocol   [optional] The protocol version
     * @param UploadedFile[]|array       $files      [optional] The files
     *
     * @throws InvalidArgumentException
     */
    public function __construct(
        Uri $uri = new HttpUri(),
        RequestMethod $method = RequestMethod::GET,
        Stream $body = new HttpStream(stream: PhpWrapper::input),
        array $headers = [],
        protected array $server = [],
        protected array $cookies = [],
        protected array $query = [],
        protected array $parsedBody = [],
        ProtocolVersion $protocol = ProtocolVersion::V1_1,
        protected array $files = []
    ) {
        $this->protocolVersion = $protocol;

        parent::__construct($uri, $method, $body, $headers);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getServerParams(): array
    {
        return $this->server;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getServerParam(string $name, mixed $default = null): mixed
    {
        return $this->server[$name] ?? $default;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function hasServerParam(string $name): bool
    {
        return isset($this->server[$name])
            || array_key_exists($name, $this->server);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getCookieParams(): array
    {
        return $this->cookies;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withCookieParams(array $cookies): static
    {
        $new = clone $this;

        $new->cookies = $cookies;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedCookieParam(string $name, string|null $value = null): static
    {
        $new = clone $this;

        $new->cookies[$name] = $value;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getCookieParam(string $name, string|null $default = null): string|null
    {
        return $this->cookies[$name] ?? $default;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function hasCookieParam(string $name): bool
    {
        return isset($this->cookies[$name])
            || array_key_exists($name, $this->cookies);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getQueryParams(): array
    {
        return $this->query;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function onlyQueryParams(string|int ...$names): array
    {
        return $this->onlyParams($this->query, ...$names);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function exceptQueryParams(string|int ...$names): array
    {
        return $this->exceptParams($this->query, ...$names);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withQueryParams(array $query): static
    {
        $new = clone $this;

        $new->query = $query;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedQueryParam(string|int $name, mixed $value): static
    {
        $new = clone $this;

        $new->query[$name] = $value;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getQueryParam(string|int $name, mixed $default = null): mixed
    {
        return $this->query[$name] ?? $default;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function hasQueryParam(string|int $name): bool
    {
        return isset($this->query[$name])
            || array_key_exists($name, $this->query);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getUploadedFiles(): array
    {
        return $this->files;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withUploadedFiles(array $uploadedFiles): static
    {
        $new = clone $this;

        $new->files = $uploadedFiles;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedUploadedFile(UploadedFile $uploadedFile): static
    {
        $new = clone $this;

        $new->files[] = $uploadedFile;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getParsedBody(): array
    {
        return $this->parsedBody;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function onlyParsedBody(string|int ...$names): array
    {
        return $this->onlyParams($this->parsedBody, ...$names);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function exceptParsedBody(string|int ...$names): array
    {
        return $this->exceptParams($this->parsedBody, ...$names);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withParsedBody(array $data): static
    {
        $new = clone $this;

        $new->parsedBody = $data;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedParsedBodyParam(string|int $name, mixed $value): static
    {
        $new = clone $this;

        $new->parsedBody[$name] = $value;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getParsedBodyParam(string|int $name, mixed $default = null): mixed
    {
        return $this->parsedBody[$name] ?? $default;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function hasParsedBodyParam(string|int $name): bool
    {
        return isset($this->parsedBody[$name])
            || array_key_exists($name, $this->parsedBody);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getAttributes(): array
    {
        return $this->attributes;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function onlyAttributes(string ...$names): array
    {
        return $this->onlyParams($this->attributes, ...$names);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function exceptAttributes(string ...$names): array
    {
        return $this->exceptParams($this->attributes, ...$names);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getAttribute(string $name, mixed $default = null): mixed
    {
        return $this->attributes[$name] ?? $default;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAttribute(string $name, mixed $value): static
    {
        $new = clone $this;

        $new->attributes[$name] = $value;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withoutAttribute(string $name): static
    {
        $new = clone $this;

        unset($new->attributes[$name]);

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function isXmlHttpRequest(): bool
    {
        return $this->getHeaderLine(HeaderName::X_REQUESTED_WITH) === 'XMLHttpRequest';
    }

    /**
     * Retrieve only the specified params.
     *
     * @param array<array-key, mixed> $params   The params to sort through

The doc comment array<array-key, mixed> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, mixed>.

     * @param string|int              ...$names The query param names to retrieve
     *
     * @return array<array-key, mixed>

The doc comment array<array-key, mixed> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, mixed>.

     */
    protected function onlyParams(array $params, string|int ...$names): array
    {
        return array_filter(
            $params,
            static fn (string|int $name): bool => in_array($name, $names, true),
            ARRAY_FILTER_USE_KEY
        );
    }

    /**
     * Retrieve all params except the ones specified.
     *
     * @param array<array-key, mixed> $params   The params to sort through

The doc comment array<array-key, mixed> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, mixed>.

     * @param string|int              ...$names The query param names to not retrieve
     *
     * @return array<array-key, mixed>

The doc comment array<array-key, mixed> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, mixed>.

     */
    protected function exceptParams(array $params, string|int ...$names): array
    {
        return array_filter(
            $params,
            static fn (string|int $name): bool => ! in_array($name, $names, true),
            ARRAY_FILTER_USE_KEY
        );
    }
}