slickframework / http

src/Client/CurlHttpClient.php

<?php

declare(strict_types=1);

/**
 * This file is part of slick/http
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Http\Client;

use CurlHandle;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Slick\Http\Client\Exception\NetworkException;
use Slick\Http\Client\Exception\RequestException;
use Slick\Http\Message\Response;
use Slick\Http\Message\Uri;

/**
 * CurlHttpClient
 *
 * @package Slick\Http\Client
*/
final class CurlHttpClient implements ClientInterface
{
    /**
     * @var null|Uri
     */
    private ?Uri $url = null;

    /**
     * @var null|HttpClientAuthentication
     */
    private ?HttpClientAuthentication $auth = null;

    /**
     * @var array<int, int|string|list<non-falsy-string>|non-falsy-string|true>

The doc comment array<int, int|string|list<non-falsy-string>|non-falsy-string|true> at position 8 could not be parsed: Expected '>' at position 8, but found 'list'.

     */
    private array $options = [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HEADER => true
    ];

    private mixed $handler = null;

    /**
     * Creates a CURL HTTP Client
     *
     * @param Uri|null                      $url
     * @param HttpClientAuthentication|null $auth
     * @param array<int, int|list<non-falsy-string>|string|true> $options

The doc comment array<int, int|list<non-falsy-string>|string|true> at position 6 could not be parsed: Expected '>' at position 6, but found 'list'.

     */
    public function __construct(
        ?Uri $url = null,
        ?HttpClientAuthentication $auth = null,
        array $options = []
    ) {
        $this->handler = curl_init();
        $this->url = $url;
        $this->auth = $auth;

        foreach ($options as $name => $option) {
            $this->options[$name] = $option;
        }
    }

    /**
     * @inheritDoc
     */
    public function sendRequest(RequestInterface $request): ResponseInterface
    {
        $this->prepare($request);
        $result = curl_exec($this->handler);
        $errno = curl_errno($this->handler);

        switch ($errno) {
            case CURLE_OK:
                // All OK, no actions needed.
                break;
            case CURLE_COULDNT_RESOLVE_PROXY:
            case CURLE_COULDNT_RESOLVE_HOST:
            case CURLE_COULDNT_CONNECT:
            case CURLE_OPERATION_TIMEOUTED:
            case CURLE_SSL_CONNECT_ERROR:
                throw new NetworkException($request, curl_error($this->handler));
            default:
                throw new RequestException($request, curl_error($this->handler));
        }

        return $this->createResponse(\is_string($result) ? $result : '');
    }

    /**
     * Prepares the cURL handler options
     *
     * @param RequestInterface $request
     */
    private function prepare(RequestInterface $request): void
    {
        if ($this->handler) {
            $this->reset($this->handler);
        }
        $this->setUrl($request);
        $this->options[CURLOPT_CUSTOMREQUEST] = $request->getMethod();
        $this->setHeaders($request);
        $this->options[CURLOPT_POSTFIELDS] = (string) $request->getBody();

        if ($this->auth instanceof HttpClientAuthentication) {
            $this->options[CURLOPT_USERPWD] = "{$this->auth->username()}:{$this->auth->password()}";
            $this->options[CURLOPT_HTTPAUTH] = $this->auth->type();
        }

        curl_setopt_array($this->handler, $this->options);
    }

    /**
     * Sets the URL for cURL to use
     *
     * @param RequestInterface $request
     */
    private function setUrl(RequestInterface $request): void
    {
        $target = $request->getRequestTarget();
        /** @var array{scheme?: string, host?: string, port?: int<0, 65535>, user?: string, pass?: string,
         *     path?: string, query?: string, fragment?: string}|false $parts */
        $parts = parse_url($target);

        $uri = $this->url instanceof Uri
            ? $this->url
            : $request->getUri();

        if (\is_array($parts)) {

The condition is_array($parts) is always true.

            $uri = \array_key_exists('path', $parts) ? $uri->withPath($parts['path']) : $uri;
            $uri =  \array_key_exists('query', $parts)
                ? $uri->withQuery($parts['query'])
                : $uri;
        }


        $this->options[CURLOPT_URL] = (string) $uri;
    }

    /**
     * Sets the headers from the request
     *
     * @param RequestInterface $request
     */
    private function setHeaders(RequestInterface $request): void
    {
        $headers = [];
        foreach ($request->getHeaders() as $header => $values) {
            $headers[] = "$header: ".implode('; ', $values);
        }
        $this->options[CURLOPT_HTTPHEADER] = $headers;
    }

    /**
     * Resets the cURL handler
     *
     * @param resource $handler
     * @param-out CurlHandle|false $handler
     */
    private function reset(&$handler): void
    {
        $handler = curl_init();
    }

    /**
     * Creates a response from cURL execution result
     *
     * @param string $result
     *
     * @return Response
     */
    private function createResponse(string $result): Response
    {
        $status = curl_getinfo($this->handler, CURLINFO_HTTP_CODE);
        list($header, $body) = $this->splitHeaderFromBody($result);
        return new Response($status, trim($body), $this->parseHeaders($header));
    }

    /**
     * Splits the cURL execution result into header and body
     *
     * @param string $result
     *
     * @return array{0: string, 1: string}
     */
    private function splitHeaderFromBody(string $result): array
    {
        $headerSize = curl_getinfo($this->handler, CURLINFO_HEADER_SIZE);

        $header = substr($result, 0, $headerSize);
        $body = substr($result, $headerSize);

        return [trim($header), trim($body)];
    }

    /**
     * Parses the HTTP message headers from header part
     *
     * @param string $header
     *
     * @return array<string>
     */
    private function parseHeaders(string $header): array
    {
        $lines = explode("\n", $header);
        $headers = [];
        foreach ($lines as $line) {
            if (!str_contains($line, ':')) {
                continue;
            }

            $middle = explode(":", $line);
            $headers[trim($middle[0])] = trim($middle[1]);
        }
        return $headers;
    }

    /**
     * Close the cURL handler on destruct
     */
    public function __destruct()
    {
        if ($this->handler) {
            curl_close($this->handler);
        }
    }
}