bearsunday / BEAR.Resource

src/HttpRequestCurl.php

<?php

declare(strict_types=1);

namespace BEAR\Resource;

use CurlHandle;
use Override;
use RuntimeException;

use function assert;
use function count;
use function curl_exec;
use function curl_getinfo;
use function curl_init;
use function curl_setopt;
use function explode;
use function http_build_query;
use function json_decode;
use function str_contains;
use function strtolower;
use function substr;
use function trim;

use const CURLINFO_CONTENT_TYPE;
use const CURLINFO_HEADER_SIZE;
use const CURLINFO_HTTP_CODE;
use const CURLOPT_CUSTOMREQUEST;
use const CURLOPT_HEADER;
use const CURLOPT_HTTPHEADER;
use const CURLOPT_POSTFIELDS;
use const CURLOPT_RETURNTRANSFER;
use const CURLOPT_URL;

/**
 * Sends a HTTP request using cURL
 *
 * @psalm-import-type Query from Types
 * @psalm-import-type HttpHeaders from Types
 * @psalm-import-type HttpBody from Types
 * @psalm-import-type RequestOptions from Types
 */
final class HttpRequestCurl implements HttpRequestInterface
{
    public function __construct(
        private readonly HttpRequestHeaders $requestHeaders,
    ) {
    }

    /** @inheritDoc */
    #[Override]
    public function request(string $method, string $uri, array $query): array
    {
        $body = http_build_query($query);
        $curl = $this->initializeCurl($method, $uri, $body);
        $response = (string) curl_exec($curl);
        $code = (int) curl_getinfo($curl, CURLINFO_HTTP_CODE);
        $headerSize = (int) curl_getinfo($curl, CURLINFO_HEADER_SIZE);
        $headerString = substr($response, 0, $headerSize);
        $view = substr($response, $headerSize);
        $headers = $this->parseResponseHeaders($headerString);

        $body = $this->parseBody($curl, $view);

        return [
            'code' => $code,
            'headers' => $headers,
            'body' => $body,
            'view' => $view,
        ];
    }

    private function initializeCurl(string $method, string $uri, string $body): CurlHandle
    {
        $curl = curl_init();
        if ($curl === false) {
            throw new RuntimeException('Failed to initialize cURL'); // @codeCoverageIgnore
        }

        assert($method !== '');
        assert($uri !== '');
        curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
        curl_setopt($curl, CURLOPT_URL, $uri);

        if ($this->requestHeaders->headers !== []) {
            curl_setopt($curl, CURLOPT_HTTPHEADER, $this->requestHeaders->headers);
        }

        if ($body !== '') {
            // Set the request body
            curl_setopt($curl, CURLOPT_POSTFIELDS, $body);
        }

        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_HEADER, true);

        return $curl;

The expression return $curl could return the type resource which is incompatible with the type-hinted return CurlHandle. Consider adding an additional type-check to rule them out.

    }

    /** @return HttpHeaders */
    private function parseResponseHeaders(string $responseHeaders): array
    {
        $responseHeadersArray = [];
        $headerLines = explode("\r\n", $responseHeaders);
        foreach ($headerLines as $line) {
            $parts = explode(':', $line, 2);
            if (count($parts) !== 2) {
                continue;
            }

            $key = $parts[0];

            $responseHeadersArray[$key] = trim($parts[1]);
        }

        return $responseHeadersArray;

The expression return $responseHeadersArray returns the type array which is incompatible with the documented return type BEAR\Resource\HttpHeaders.

    }

    /** @return HttpBody */
    private function parseBody(CurlHandle $curl, string $view): array
    {
        $responseBody = [];
        $contentType = (string) curl_getinfo($curl, CURLINFO_CONTENT_TYPE);
        if (str_contains(strtolower($contentType), 'application/json')) {
            return (array) json_decode($view, true);

The expression return (array)json_decode($view, true) returns the type array which is incompatible with the documented return type BEAR\Resource\HttpBody.

        }

        return $responseBody;

The expression return $responseBody returns the type array which is incompatible with the documented return type BEAR\Resource\HttpBody.

    }
}