OAuthClient::refreshAccessToken() - Code Metrics - Inspection of "Merge pull request #1 from sarahman/compatible-wit..." - sarahman/oauth-tokens-client - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0c1c89...527c73 )

by Syed Abidur

created 2025-07-11 16:30 UTC

OAuthClient::refreshAccessToken() B

↳ Parent: OAuthClient

Complexity

Conditions	8
Paths	16

Size

Total Lines	47
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	8
eloc	29
nc	16
nop	0
dl	0
loc	47
rs	8.2114
c	0
b	0
f	0

<?php

namespace Sarahman\OauthTokensClient;

use Exception;
use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use Illuminate\Cache\Repository as CacheRepository;

class OAuthClient
{
    private static $accessTokenKey;
    private static $refreshTokenKey;
    private static $lockKey;

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

    /** @var CacheRepository */
    private $cache;

    private $tokenUrl;
    private $refreshUrl;
    private $grantType;
    private $clientId;
    private $clientSecret;
    private $username;
    private $password;
    private $scope = '';

    public function __construct(Client $httpClient, CacheRepository $cache, array $oauthConfig, array $tokenPrefixes, $lockKey)
    {
        $this->httpClient = $httpClient;
        $this->cache = $cache;
        $this->tokenUrl = $oauthConfig['TOKEN_URL'];
        $this->refreshUrl = $oauthConfig['REFRESH_URL'];
        $this->grantType = $oauthConfig['GRANT_TYPE'];
        $this->clientId = $oauthConfig['CLIENT_ID'];
        $this->clientSecret = $oauthConfig['CLIENT_SECRET'];
        $this->username = $oauthConfig['USERNAME'];
        $this->password = $oauthConfig['PASSWORD'];
        $this->scope = $oauthConfig['SCOPE'];

        self::$accessTokenKey = $tokenPrefixes['ACCESS'];
        self::$refreshTokenKey = $tokenPrefixes['REFRESH'];
        self::$lockKey = $lockKey;
    }

    public function request($method, $uri, array $options = array(), $retryCount = 1)
    {
        isset($options['headers']) || $options['headers'] = array();
        $options['headers']['Authorization'] = "Bearer {$this->getAccessToken()}";

        try {
            return $this->httpClient->request($method, $uri, $options);
        } catch (RequestException $e) {
            $response = $e->getResponse();

            if ($response && $response->getStatusCode() === 401 && $retryCount > 0) {
                $options['headers']['Authorization'] = "Bearer {$this->refreshAccessToken()}";

                return $this->request($method, $uri, $options, $retryCount - 1);
            }

            throw $e;
        }
    }

    private function getAccessToken()
    {
        $token = $this->cache->get(self::$accessTokenKey);

        if ($token) {
            return $token;
        }

        while ($this->cache->has(self::$lockKey)) {
            usleep(50000); // wait 50ms
        }

        return $this->refreshAccessToken();
    }

    private function refreshAccessToken()
    {
        if ($this->cache->has(self::$lockKey)) {
            while ($this->cache->has(self::$lockKey)) {
                usleep(50000);
            }

            return $this->cache->get(self::$accessTokenKey);
        }

        $this->cache->put(self::$lockKey, true, 10);

        try {
            $token = '';
            $refreshToken = $this->cache->get(self::$refreshTokenKey);

            if (!$refreshToken) {
                $token = $this->fetchInitialTokens();
            } else {
                $response = $this->httpClient->post($this->refreshUrl, array(
                    'form_params' => array(
                        'grant_type'    => 'refresh_token',
                        'refresh_token' => $refreshToken,
                        'client_id'     => $this->clientId,
                        'client_secret' => $this->clientSecret,
                        'scope'         => $this->scope,
                    ),
                ));

                $token = $this->parseAndStoreTokens($response);
            }
        } catch (RequestException $e) {
            $response = $e->getResponse();

            if ($response && $response->getStatusCode() === 401) {
                return $this->fetchInitialTokens();
            }

            throw $e;
        } catch (Exception $e) {
            $this->cache->forget(self::$lockKey);
            throw $e;
        }

        $this->cache->forget(self::$lockKey);

        return $token;
    }

    private function fetchInitialTokens()
    {
        $params = array(
            'grant_type' => $this->grantType,
            'client_id'  => $this->clientId,
            'client_secret' => $this->clientSecret,
        );

        if ('password' === $this->grantType && $this->username && $this->password) {
            $params['username'] = $this->username;
            $params['password'] = $this->password;
        }

        $response = $this->httpClient->post($this->tokenUrl, array(
            'form_params' => $params,
        ));

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

    /**
     * Parses the OAuth token response and stores the tokens.
     *
     * @param \GuzzleHttp\Message\ResponseInterface|\Psr\Http\Message\ResponseInterface $response
filter:
    dependency_paths: ["lib/*"]
     *
     * @return string
     */
    private function parseAndStoreTokens($response)
    {
        $data = json_decode((string) $response->getBody(), true);

        if (json_last_error()) {
            return '';
        }

        $this->storeTokens($data);

        return $data['access_token'];
    }

    private function storeTokens(array $data)
    {
        $this->cache->put(self::$accessTokenKey, $data['access_token'], $data['expires_in'] - 30);
        $this->cache->forever(self::$refreshTokenKey, $data['refresh_token']);
    }
}


1			<?php
2
3			namespace Sarahman\OauthTokensClient;
4
5			use Exception;
6			use GuzzleHttp\Client;
7			use GuzzleHttp\Exception\RequestException;
8			use Illuminate\Cache\Repository as CacheRepository;
9
10			class OAuthClient
11			{
12			private static $accessTokenKey;
13			private static $refreshTokenKey;
14			private static $lockKey;
15
16			/** @var Client */
17			private $httpClient;
18
19			/** @var CacheRepository */
20			private $cache;
21
22			private $tokenUrl;
23			private $refreshUrl;
24			private $grantType;
25			private $clientId;
26			private $clientSecret;
27			private $username;
28			private $password;
29			private $scope = '';
30
31			public function __construct(Client $httpClient, CacheRepository $cache, array $oauthConfig, array $tokenPrefixes, $lockKey)
32			{
33			$this->httpClient = $httpClient;
34			$this->cache = $cache;
35			$this->tokenUrl = $oauthConfig['TOKEN_URL'];
36			$this->refreshUrl = $oauthConfig['REFRESH_URL'];
37			$this->grantType = $oauthConfig['GRANT_TYPE'];
38			$this->clientId = $oauthConfig['CLIENT_ID'];
39			$this->clientSecret = $oauthConfig['CLIENT_SECRET'];
40			$this->username = $oauthConfig['USERNAME'];
41			$this->password = $oauthConfig['PASSWORD'];
42			$this->scope = $oauthConfig['SCOPE'];
43
44			self::$accessTokenKey = $tokenPrefixes['ACCESS'];
45			self::$refreshTokenKey = $tokenPrefixes['REFRESH'];
46			self::$lockKey = $lockKey;
47			}
48
49			public function request($method, $uri, array $options = array(), $retryCount = 1)
50			{
51			isset($options['headers']) \|\| $options['headers'] = array();
52			$options['headers']['Authorization'] = "Bearer {$this->getAccessToken()}";
53
54			try {
55			return $this->httpClient->request($method, $uri, $options);
56			} catch (RequestException $e) {
57			$response = $e->getResponse();
58
59			if ($response && $response->getStatusCode() === 401 && $retryCount > 0) {
60			$options['headers']['Authorization'] = "Bearer {$this->refreshAccessToken()}";
61
62			return $this->request($method, $uri, $options, $retryCount - 1);
63			}
64
65			throw $e;
66			}
67			}
68
69			private function getAccessToken()
70			{
71			$token = $this->cache->get(self::$accessTokenKey);
72
73			if ($token) {
74			return $token;
75			}
76
77			while ($this->cache->has(self::$lockKey)) {
78			usleep(50000); // wait 50ms
79			}
80
81			return $this->refreshAccessToken();
82			}
83
84			private function refreshAccessToken()
85			{
86			if ($this->cache->has(self::$lockKey)) {
87			while ($this->cache->has(self::$lockKey)) {
88			usleep(50000);
89			}
90
91			return $this->cache->get(self::$accessTokenKey);
92			}
93
94			$this->cache->put(self::$lockKey, true, 10);
95
96			try {
97			$token = '';
98			$refreshToken = $this->cache->get(self::$refreshTokenKey);
99
100			if (!$refreshToken) {
101			$token = $this->fetchInitialTokens();
102			} else {
103			$response = $this->httpClient->post($this->refreshUrl, array(
104			'form_params' => array(
105			'grant_type' => 'refresh_token',
106			'refresh_token' => $refreshToken,
107			'client_id' => $this->clientId,
108			'client_secret' => $this->clientSecret,
109			'scope' => $this->scope,
110			),
111			));
112
113			$token = $this->parseAndStoreTokens($response);
114			}
115			} catch (RequestException $e) {
116			$response = $e->getResponse();
117
118			if ($response && $response->getStatusCode() === 401) {
119			return $this->fetchInitialTokens();
120			}
121
122			throw $e;
123			} catch (Exception $e) {
124			$this->cache->forget(self::$lockKey);
125			throw $e;
126			}
127
128			$this->cache->forget(self::$lockKey);
129
130			return $token;
131			}
132
133			private function fetchInitialTokens()
134			{
135			$params = array(
136			'grant_type' => $this->grantType,
137			'client_id' => $this->clientId,
138			'client_secret' => $this->clientSecret,
139			);
140
141			if ('password' === $this->grantType && $this->username && $this->password) {
142			$params['username'] = $this->username;
143			$params['password'] = $this->password;
144			}
145
146			$response = $this->httpClient->post($this->tokenUrl, array(
147			'form_params' => $params,
148			));
149
150			return $this->parseAndStoreTokens($response);
151			}
152
153			/**
154			* Parses the OAuth token response and stores the tokens.
155			*
156			* @param \GuzzleHttp\Message\ResponseInterface\|\Psr\Http\Message\ResponseInterface $response
			0 ignored issues – show Bug introduced 2025-06-24 21:31 UTC by Report Bug Copy Issue Report The type `GuzzleHttp\Message\ResponseInterface` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
157			*
158			* @return string
159			*/
160			private function parseAndStoreTokens($response)
161			{
162			$data = json_decode((string) $response->getBody(), true);
163
164			if (json_last_error()) {
165			return '';
166			}
167
168			$this->storeTokens($data);
169
170			return $data['access_token'];
171			}
172
173			private function storeTokens(array $data)
174			{
175			$this->cache->put(self::$accessTokenKey, $data['access_token'], $data['expires_in'] - 30);
176			$this->cache->forever(self::$refreshTokenKey, $data['refresh_token']);
177			}
178			}
179

sarahman / oauth-tokens-client

Push — master ( 0c1c89...527c73 )

OAuthClient::refreshAccessToken() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like