minulislam / multicoin-api

src/Service/ApiClient.php

<?php

namespace Multicoin\Api\Service;

use Exception;
use Http\Client\Common\Exception\ClientErrorException;
use Http\Client\Common\HttpMethodsClient;
use Http\Client\Common\Plugin\BaseUriPlugin;
use Http\Client\Common\PluginClient;
use Http\Client\HttpClient;
use Http\Discovery\HttpClientDiscovery;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Discovery\UriFactoryDiscovery;
use Http\Message\RequestFactory;
use Http\Message\UriFactory;
use Illuminate\Support\Collection;

class ApiClient
{
    protected $client;

Protected member variable "client" must contain a leading underscore

    /**
     * @var HttpClient
     */
    protected $httpClient;

Protected member variable "httpClient" must contain a leading underscore

    protected $plugins = [];

Protected member variable "plugins" must contain a leading underscore

    /**
     * @var RequestFactory
     */
    private $requestFactory;

Private member variable "requestFactory" must contain a leading underscore

    /**
     * @var UriFactory
     */
    private $uriFactory;

Private member variable "uriFactory" must contain a leading underscore

    public function __construct(
        string $baseUrl,
        array $plugins = [],
        bool $replace = true,
        HttpClient $httpClient = null,
        RequestFactory $requestFactory = null
    ) {
        $this->requestFactory = $requestFactory ?: MessageFactoryDiscovery::find();
        $this->httpClient = $httpClient ?: HttpClientDiscovery::find();
        $this->uriFactory = new BaseUriPlugin(

It seems like new Http\Client\Common\Plugin\BaseUriPlugin(Http\Discovery\UriFactoryDiscovery::find()->createUri($baseUrl), array('replace' => $replace)) of type Http\Client\Common\Plugin\BaseUriPlugin is incompatible with the declared type Http\Message\UriFactory of property $uriFactory.

            UriFactoryDiscovery::find()->createUri($baseUrl),
            ['replace' => $replace]
        );
        $this->addPlugins(array_merge($plugins, [$this->uriFactory]));
        $this->client = $this->getHttpClient();
    }

    public function addPlugins($plugin)
    {
        $this->plugins = array_merge($this->plugins, $plugin);
        $this->client = $this->getHttpClient();

        return $this;
    }

    public function getHttpClient()
    {
        return new HttpMethodsClient($this->getPluginClient(), $this->requestFactory);
    }

    public function getPluginClient()
    {
        return new PluginClient($this->httpClient, $this->plugins);
    }

    public function doGet(string $url): ?Collection
    {
        try {
            $request = $this->client->get($url);
            $response = $request->getBody()->getContents();
        } catch (ClientErrorException $exception) {
            throw new \Exception($exception);
            throw new Exception($exception->getMessage()." Error Processing Request for [$url]", 1);

As per coding-style, please use concatenation or sprintf for the variable $url instead of interpolation.

ThrowNode is not reachable.

            return collect([
                'error' => [
                    'code' => $exception->getCode(),
                    'reason' => $exception->getMessage(),
                ],
            ]);
        }

        return $this->responseResult($response);
    }

    public function doPost(string $url, array $data = []): ?Collection
    {
        try {
            $request = $this->client->post($url, $data);
            $response = $request->getBody()->getContents();
        } catch (ClientErrorException $exception) {
            throw new \Exception($exception);
            // throw new Exception($exception->getMessage()." Error Processing Request for [$url]", 1);

            return collect([

return collect(array('error' => array('code' => $exception->getCode(), 'reason' => $exception->getMessage()))) is not reachable.

                'error' => [
                    'code' => $exception->getCode(),
                    'reason' => $exception->getMessage(),
                ],
            ]);
        }

        return $this->responseResult($response);
    }

    protected function responseResult(?string $response): ?Collection
    {
        $data = json_decode($response, true);

It seems like $response can also be of type null; however, parameter $json of json_decode() does only seem to accept string, maybe add an additional type check?

        if (isset($data['error'])) {
            throw new Exception($data['error']['message']);
        }

        return collect($data);
    }
}