ShopifyClient\Request

Complexity

Total Complexity

15

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	request()	0	23	3
A	setResponseKey()	0	4	1
A	throttle()	0	14	2
A	getRateLimitReached()	0	4	1
A	handleRateLimit()	0	9	3
A	setRateLimit()	0	10	2
A	isRateLimitReached()	0	4	1
A	getCallLimit()	0	4	1

<?php

namespace ShopifyClient;

use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\ClientException;
use ShopifyClient\Exception\ShopifyException;

class Request
{
    const API_CALL_LIMIT_HEADER = 'http_x_shopify_shop_api_call_limit';

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

    /**
     * @var string
     */
    protected $responseKey;

    /**
     * @var int
     */
    private $rateLimit;

    /**
     * @var int
     */
    private $callsMade;

    /**
     * @var float
     */
    private static $callCycle = 0.5; // avg. 2 calls a second

    /**
     * @var float
     */
    private $rateLimitThreshold = 0.8;

    /**
     * @var int
     */
    private $rateLimitReached = 0;

    /**
     * Request constructor.
     * @param ClientInterface $client
     */
    public function __construct(ClientInterface $client)
    {
        $this->httpClient = $client;

It seems like $client of type object<GuzzleHttp\ClientInterface> is incompatible with the declared type object<ShopifyClient\Client> of property $httpClient.

    }

    /**
     * @param string $method
     * @param string $endpoint
     * @param array $parameters
     * @return bool
     * @throws ShopifyException
     */
    public function request(string $method, string $endpoint, array $parameters = [])
    {
        $this->handleRateLimit();

        try {
            $response = $this->httpClient->request($method, $endpoint, $parameters);

The method request() does not seem to exist on object<ShopifyClient\Client>.

        } catch (ClientException $e) {
            $response = $e->getResponse();
            $content  = json_decode($response->getBody()->getContents(), true);

            throw new ShopifyException($content['errors'], $response->getStatusCode(), $e);
        }

        $this->setRateLimit($response->getHeader(self::API_CALL_LIMIT_HEADER));

        $data = json_decode($response->getBody()->getContents(), true);

        if (strlen($this->responseKey) > 0) {
            return $data[$this->responseKey];
        } else {
            return true;
        }
    }

    /**
     * @param string $responseKey
     * @return Request
     */
    public function setResponseKey($responseKey)
    {
        $this->responseKey = $responseKey;
    }

    /**
     * @param callable $function
     * @return mixed
     */
    public static function throttle(callable $function)
    {
        $start    = time();
        $result   = $function();
        $end      = time();
        $duration = $end - $start;
        $waitTime = ceil(static::$callCycle - $duration);

Since $callCycle is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $callCycle to at least protected.

        if ($waitTime > 0) {
            sleep($waitTime);
        }

        return $result;
    }

    /**
     * @return int
     */
    public function getRateLimitReached(): int
    {
        return $this->rateLimitReached;
    }

    private function handleRateLimit()
    {
        if ($this->callsMade > 0 && $this->isRateLimitReached()) {
            $this->rateLimitReached++;
            // Prevent bucket overflow
            // https://help.shopify.com/api/getting-started/api-call-limit
            usleep(rand(3, 10) * 1000000);
        }
    }

    /**
     * @param array $header
     */
    private function setRateLimit(array $header)
    {
        if (empty($header)) {
            return;
        }

        $parts           = explode('/', $header[0]);
        $this->rateLimit = $parts[1];
        $this->callsMade = $parts[0];
    }

    /**
     * @return bool
     */
    public function isRateLimitReached(): bool
    {
        return $this->getCallLimit() >= $this->rateLimitThreshold;
    }

    /**
     * @return float|int
     */
    public function getCallLimit()
    {
        return $this->callsMade / $this->rateLimit;
    }
}