Does Guzzle Client inherit Client from handler? - php

Question

Using PHP 8.1, Laravel 9, Guzzle 7.4.2.
I have this snippet in a service singleton registered in AppServiceProvider:
$middleware = new AccessTokenGuzzleMiddleware(
client: new Client([
'base_uri' => config('spica.url') . config('spica.space_api.path'),
'verify' => config('spica.verify_ssl'),
]),
cache: $this->app->make('cache')->store(),
tokenUrl: config('spica.url') . 'auth',
clientId: config('spica.space_api.client_id'),
clientSecret: config('spica.space_api.key'),
);
$stack = HandlerStack::create();
$stack->push($middleware);
$spaceClient = new Client([
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
],
'handler' => $stack,
'base_uri' => config('spica.url') . config('spica.space_api.path'),
'verify' => config('spica.verify_ssl'),
]);
I can't test myself, because I have no access to base_uri, and it will only be tested once on development server, but I am curious if the Client inherits anything from the handler stack, and how does it do so if there are multiple middlewares stacked in handler?
Asking because all the examples in Guzzle docs create the final client with just $client = new Client(['handler' => $stack]);.
As you can see I currently repeat base_uri and verify lines.
Would the following work the same?
$middleware = new AccessTokenGuzzleMiddleware(
client: new Client([
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
],
'base_uri' => config('spica.url') . config('spica.space_api.path'),
'verify' => config('spica.verify_ssl'),
]),
cache: $this->app->make('cache')->store(),
tokenUrl: config('spica.url') . 'auth',
clientId: config('spica.space_api.client_id'),
clientSecret: config('spica.space_api.key'),
);
$stack = HandlerStack::create();
$stack->push($middleware);
$spaceClient = new Client(['handler' => $stack]);
For completeness, here's the AccessTokenGuzzleMiddleware class:
<?php
declare(strict_types=1);
namespace App\Support;
use GuzzleHttp\Client;
use Psr\Http\Message\RequestInterface;
use Illuminate\Contracts\Cache\Repository as CacheContract;
/**
* This is a Guzzle middleware (see more at https://docs.guzzlephp.org/en/stable/handlers-and-middleware.html).
* It adds "Authorization: Bearer" header to requests.
*/
class AccessTokenGuzzleMiddleware
{
public function __construct(
private Client $client,
private CacheContract $cache,
private string $tokenUrl,
private string $clientId,
private string $clientSecret
) {
}
public function __invoke(callable $handler)
{
return function (RequestInterface $request, array $options) use ($handler) {
$request = $request->withHeader('Authorization', 'Bearer ' . $this->getAccessToken());
return $handler($request, $options);
};
}
/**
* Defines cache key for access token.
*
* #return string
*/
private function cacheKey(): string
{
return self::class . $this->tokenUrl . $this->clientId . $this->clientSecret;
}
/**
* Get access token from cache or external API.
*
* #return string
*/
private function getAccessToken(): string
{
$cacheKey = $this->cacheKey();
if ($this->cache->has($cacheKey)) {
return $this->cache->get($cacheKey);
}
$tokenData = $this->retrieveClientAccessTokenData();
$this->cache->set(
key: $cacheKey,
value: $tokenData->access_token,
ttl: $tokenData->expires_in - 10
);
return $tokenData->access_token;
}
/**
* This is effectively the client (this service, not on behalf of a user)
* authenticating itself.
*/
private function retrieveClientAccessTokenData(): object
{
$authResponse = $this->client->post($this->tokenUrl, [
'json' => [
'apiKey' => $this->clientSecret,
'client_id' => $this->clientSecret,
],
]);
assertResponseOk($authResponse);
return json_decode($authResponse->getBody()->getContents());
}
}
EDIT 1
Until I get a better answer, I went with the following:
$this->app->singleton(KeycloakService::class, function (Application $app) {
// Log all Guzzle HTTP requests and responses.
// https://github.com/gmponos/guzzle-log-middleware#advanced-initialization
$middleware = new OAuthGuzzleMiddleware(
client: new Client(['verify' => config('keycloak.verify_ssl')]),
cache: $this->app->make('cache')->store(),
tokenUrl: config('keycloak.url') . 'auth/realms/' . config('keycloak.realm') . '/protocol/openid-connect/token',
clientId: config('keycloak.client_id'),
clientSecret: config('keycloak.client_secret'),
);
$stack = HandlerStack::create();
$stack->push($middleware);
$oAuthKeycloakClient = new Client([
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
],
'handler' => $stack,
'base_uri' => config('keycloak.url') . 'auth/admin/realms/' . config('keycloak.realm') . '/',
'verify' => config('keycloak.verify_ssl'),
]);
return new KeycloakService(
client: $oAuthKeycloakClient,
groupHandler: new GroupHandler(),
userHandler: new UserHandler(),
);
});
$this->app->singleton(SpicaService::class, function (Application $app) {
// Time API
$timeClient = new Client([
'base_uri' => config('spica.url') . config('spica.time_api.path'),
'headers' => [
'Content-Type' => 'application/x-www-form-urlencoded',
'Accept' => 'application/json',
'Authorization' => config('spica.time_api.auth_token'),
],
'verify' => config('spica.verify_ssl'),
]);
// Space API
$middleware = new AccessTokenGuzzleMiddleware(
client: new Client(['verify' => config('spica.verify_ssl')]),
cache: $this->app->make('cache')->store(),
tokenUrl: config('spica.url') . 'auth',
clientId: config('spica.space_api.client_id'),
clientSecret: config('spica.space_api.key'),
);
$stack = HandlerStack::create();
$stack->push($middleware);
$spaceClient = new Client([
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
],
'handler' => $stack,
'base_uri' => config('spica.url') . config('spica.space_api.path'),
'verify' => config('spica.verify_ssl'),
]);
// Create service
return new SpicaService(
timeClient: $timeClient,
spaceClient: $spaceClient,
employeeHandler: new EmployeeHandler(),
);
});

Answer 1

That's not really how Guzzle works. So there's three concepts in Guzzle that you're trying to mix up, Client, Middleware and Handler which I'll try to explain.
With the Client you build the request and prepare it for the middleware/handler, this is where you define what the request is.
The Handler executes the request, note: when you create a Handlerstack::create() the default handler will be the CurlHandler, you can overwrite the handler here as a parameter
The Middleware is used to modify the request or response after the request is executed. But the request will eventually be passed to the handler to execute it.
What you can do is provide the client as a service in the AppServiceProvider
$this->app->bind(Client::class, function () {
return new Client([
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
],
'base_uri' => config('spica.url') . config('spica.space_api.path'),
'verify' => config('spica.verify_ssl'),
]);
});
That way everywhere the Client is injected in the constructor it will inject that pre-configured client
Edit:
Just realised that would miss the handler in some cases, you could provide it as a singleton and overwrite the client when you've authenticated
Edit with contextual binding:
$this->app->when(KeycloakService::class)
->needs(Client::class)
->give(function () {
return new Client();
});
$this->app->when(KeycloakService::class)
->needs(Client::class)
->give(function () {
return new Client();
});
$this->app->when(AccessTokenGuzzleMiddleware::class)
->needs(Client::class)
->give(function () {
return new Client([
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
],
'base_uri' => config('spica.url') . config('spica.space_api.path'),
'verify' => config('spica.verify_ssl'),
]);
});