├── .gitignore
├── src
    ├── ServiceException.php
    ├── Http
    │   ├── Body.php
    │   ├── GET.php
    │   ├── PUT.php
    │   ├── HEAD.php
    │   ├── POST.php
    │   ├── DELETE.php
    │   ├── PATCH.php
    │   ├── OPTIONS.php
    │   ├── FieldValue.php
    │   ├── HeaderValue.php
    │   ├── Header.php
    │   └── HTTP.php
    ├── Call.php
    ├── Internal
    │   ├── Service.php
    │   └── ServiceCall.php
    ├── Interceptor
    │   └── RequireSuccessfulResponse.php
    └── ServiceFactory.php
├── .phpstorm.meta.php
├── composer.json
├── LICENSE
├── README.md
└── examples
    └── github.php


/.gitignore:
--------------------------------------------------------------------------------
1 | vendor
2 | composer.lock


--------------------------------------------------------------------------------
/src/ServiceException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Kelunik\Aerial;
4 | 
5 | final class ServiceException extends \Exception
6 | {
7 | }


--------------------------------------------------------------------------------
/src/Http/Body.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Kelunik\Aerial\Http;
4 | 
5 | #[\Attribute(\Attribute::TARGET_PARAMETER)]
6 | final class Body
7 | {
8 | }


--------------------------------------------------------------------------------
/.phpstorm.meta.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace PHPSTORM_META {
4 |     override(\Kelunik\Aerial\ServiceFactory::build(0), type(0));
5 |     override(\Kelunik\Aerial\Internal\ServiceCall::attribute(0, 1), type(1));
6 | }


--------------------------------------------------------------------------------
/src/Http/GET.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_METHOD)]
 6 | final class GET extends HTTP
 7 | {
 8 |     public function __construct(string $uri)
 9 |     {
10 |         parent::__construct('GET', $uri);
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/Http/PUT.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_METHOD)]
 6 | final class PUT extends HTTP
 7 | {
 8 |     public function __construct(string $uri)
 9 |     {
10 |         parent::__construct('PUT', $uri);
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/Http/HEAD.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_METHOD)]
 6 | final class HEAD extends HTTP
 7 | {
 8 |     public function __construct(string $uri)
 9 |     {
10 |         parent::__construct('HEAD', $uri);
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/Http/POST.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_METHOD)]
 6 | final class POST extends HTTP
 7 | {
 8 |     public function __construct(string $uri)
 9 |     {
10 |         parent::__construct('POST', $uri);
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/Http/DELETE.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_METHOD)]
 6 | final class DELETE extends HTTP
 7 | {
 8 |     public function __construct(string $uri)
 9 |     {
10 |         parent::__construct('DELETE', $uri);
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/Http/PATCH.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_METHOD)]
 6 | final class PATCH extends HTTP
 7 | {
 8 |     public function __construct(string $uri)
 9 |     {
10 |         parent::__construct('PATCH', $uri);
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/Http/OPTIONS.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_METHOD)]
 6 | final class OPTIONS extends HTTP
 7 | {
 8 |     public function __construct(string $uri)
 9 |     {
10 |         parent::__construct('OPTIONS', $uri);
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/Http/FieldValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_PARAMETER)]
 6 | final class FieldValue
 7 | {
 8 |     public function __construct(
 9 |         private string $name
10 |     ) {
11 |     }
12 | 
13 |     public function getName(): string
14 |     {
15 |         return $this->name;
16 |     }
17 | }


--------------------------------------------------------------------------------
/src/Http/HeaderValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_PARAMETER)]
 6 | final class HeaderValue
 7 | {
 8 |     public function __construct(
 9 |         private string $name,
10 |     ) {
11 |     }
12 | 
13 |     public function getName(): string
14 |     {
15 |         return $this->name;
16 |     }
17 | }


--------------------------------------------------------------------------------
/src/Call.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial;
 4 | 
 5 | use Amp\Cancellation;
 6 | use Amp\Http\Client\Request;
 7 | use Amp\Http\Client\Response;
 8 | 
 9 | /**
10 |  * @template T
11 |  */
12 | interface Call
13 | {
14 |     /**
15 |      * @return T
16 |      */
17 |     public function execute(?Cancellation $cancellation = null): mixed;
18 | 
19 |     public function getRequest(): Request;
20 | 
21 |     public function getResponse(): Response;
22 | }


--------------------------------------------------------------------------------
/src/Http/Header.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | #[\Attribute(\Attribute::TARGET_METHOD)]
 6 | final class Header
 7 | {
 8 |     public function __construct(
 9 |         private string $name,
10 |         private string $value
11 |     ) {
12 |     }
13 | 
14 |     public function getName(): string
15 |     {
16 |         return $this->name;
17 |     }
18 | 
19 |     public function getValue(): string
20 |     {
21 |         return $this->value;
22 |     }
23 | }


--------------------------------------------------------------------------------
/src/Http/HTTP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Http;
 4 | 
 5 | use League\Uri\UriTemplate;
 6 | 
 7 | #[\Attribute(\Attribute::TARGET_METHOD)]
 8 | class HTTP
 9 | {
10 |     private string $method;
11 |     private string $uri;
12 | 
13 |     public function __construct(string $method, string $uri)
14 |     {
15 |         $this->method = $method;
16 |         $this->uri = $uri;
17 |     }
18 | 
19 |     public function getUri(): string
20 |     {
21 |         return $this->uri;
22 |     }
23 | 
24 |     public function getMethod(): string
25 |     {
26 |         return $this->method;
27 |     }
28 | }


--------------------------------------------------------------------------------
/src/Internal/Service.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Internal;
 4 | 
 5 | use Kelunik\Aerial\Call;
 6 | 
 7 | /** @internal */
 8 | final class Service
 9 | {
10 |     /** @var ServiceCall[] */
11 |     private array $methods;
12 | 
13 |     public function __construct(array $methods)
14 |     {
15 |         $this->methods = $methods;
16 |     }
17 | 
18 |     public function __call(string $name, array $arguments): Call
19 |     {
20 |         $serviceCall = $this->methods[\strtolower($name)] ?? throw new \BadMethodCallException('Unknown method: ' . $name);
21 |         return $serviceCall->withArguments($arguments);
22 |     }
23 | }


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "kelunik/aerial",
 3 |     "type": "library",
 4 |     "license": "MIT",
 5 |     "autoload": {
 6 |         "psr-4": {
 7 |             "Kelunik\\Aerial\\": "src"
 8 |         }
 9 |     },
10 |     "autoload-dev": {
11 |         "psr-4": {
12 |             "Kelunik\\Aerial\\": "test"
13 |         }
14 |     },
15 |     "authors": [
16 |         {
17 |             "name": "Niklas Keller",
18 |             "email": "me@kelunik.com"
19 |         }
20 |     ],
21 |     "minimum-stability": "beta",
22 |     "require": {
23 |         "php": ">=8.1",
24 |         "amphp/http-client": "^5-beta.4",
25 |         "amphp/serialization": "^1.0",
26 |         "cuyz/valinor": "^0.14.0",
27 |         "ocramius/proxy-manager": "^2.14"
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Interceptor/RequireSuccessfulResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial\Interceptor;
 4 | 
 5 | use Amp\Cancellation;
 6 | use Amp\Http\Client\ApplicationInterceptor;
 7 | use Amp\Http\Client\DelegateHttpClient;
 8 | use Amp\Http\Client\Request;
 9 | use Amp\Http\Client\Response;
10 | use Kelunik\Aerial\ServiceException;
11 | 
12 | final class RequireSuccessfulResponse implements ApplicationInterceptor
13 | {
14 |     public function request(Request $request, Cancellation $cancellation, DelegateHttpClient $httpClient): Response
15 |     {
16 |         $response = $httpClient->request($request, $cancellation);
17 | 
18 |         $status = $response->getStatus();
19 |         if ($status < 200 || $status >= 300) {
20 |             throw new ServiceException('Invalid response status: ' . $status);
21 |         }
22 | 
23 |         return $response;
24 |     }
25 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2022 Niklas Keller
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # kelunik/aerial
 2 | 
 3 | Build HTTP API clients using interface definitions.
 4 | Builds on top of [Valinor](https://github.com/CuyZ/Valinor).
 5 | It uses internal APIs, so use at your own risk for now.
 6 | 
 7 | ```php
 8 | interface GitHub
 9 | {
10 |     /** @return Call<GitHubUser> */
11 |     #[GET('/users{/user}')]
12 |     public function getUser(string $user): Call;
13 | }
14 | 
15 | final class GitHubUser
16 | {
17 |     public string $login;
18 |     public string $avatarUrl;
19 |     public string $name;
20 | }
21 | ```
22 | 
23 | ```php
24 | $httpClient = (new HttpClientBuilder())
25 |     ->intercept(new ResolveBaseUri('https://api.github.com/'))
26 |     ->intercept(new SetRequestHeader('user-agent', 'github.com/kelunik/aerial'))
27 |     ->intercept(new RequireSuccessfulResponse())
28 |     ->build();
29 | 
30 | $serializer = new class implements Serializer {
31 |     private Serializer $json;
32 | 
33 |     public function __construct()
34 |     {
35 |         $this->json = JsonSerializer::withAssociativeArrays();
36 |     }
37 | 
38 |     public function serialize($data): string
39 |     {
40 |         return $this->json->serialize($data);
41 |     }
42 | 
43 |     public function unserialize(string $data): Source
44 |     {
45 |         return Source::array($this->json->unserialize($data))->camelCaseKeys();
46 |     }
47 | };
48 | 
49 | $github = (new ServiceFactory(
50 |     $httpClient,
51 |     $serializer,
52 | ))->build(GitHub::class);
53 | ```
54 | 
55 | ```php
56 | $call = $github->getUser('kelunik');
57 | $user = $call->execute();
58 | 
59 | var_dump($user->login);
60 | var_dump($user->avatarUrl);
61 | var_dump($user->name);
62 | 
63 | var_dump($call->getResponse()->getHeader('x-ratelimit-remaining'));
64 | ```


--------------------------------------------------------------------------------
/examples/github.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Amp\Http\Client\HttpClientBuilder;
 4 | use Amp\Http\Client\Interceptor\ResolveBaseUri;
 5 | use Amp\Http\Client\Interceptor\SetRequestHeader;
 6 | use Amp\Serialization\JsonSerializer;
 7 | use Amp\Serialization\Serializer;
 8 | use CuyZ\Valinor\Mapper\Source\Source;
 9 | use Kelunik\Aerial\Call;
10 | use Kelunik\Aerial\Http\GET;
11 | use Kelunik\Aerial\Interceptor\RequireSuccessfulResponse;
12 | use Kelunik\Aerial\ServiceFactory;
13 | 
14 | require __DIR__ . '/../vendor/autoload.php';
15 | 
16 | interface GitHub
17 | {
18 |     /** @return Call<GitHubUser> */
19 |     #[GET('/users{/user}')]
20 |     public function getUser(string $user): Call;
21 | }
22 | 
23 | final class GitHubUser
24 | {
25 |     public string $login;
26 |     public string $avatarUrl;
27 |     public string $name;
28 | }
29 | 
30 | $httpClient = (new HttpClientBuilder())
31 |     ->intercept(new ResolveBaseUri('https://api.github.com/'))
32 |     ->intercept(new SetRequestHeader('user-agent', 'github.com/kelunik/aerial'))
33 |     ->intercept(new RequireSuccessfulResponse())
34 |     ->build();
35 | 
36 | $serializer = new class implements Serializer {
37 |     private Serializer $json;
38 | 
39 |     public function __construct()
40 |     {
41 |         $this->json = JsonSerializer::withAssociativeArrays();
42 |     }
43 | 
44 |     public function serialize($data): string
45 |     {
46 |         return $this->json->serialize($data);
47 |     }
48 | 
49 |     public function unserialize(string $data): Source
50 |     {
51 |         return Source::array($this->json->unserialize($data))->camelCaseKeys();
52 |     }
53 | };
54 | 
55 | $github = (new ServiceFactory(
56 |     $httpClient,
57 |     $serializer,
58 | ))->build(GitHub::class);
59 | 
60 | $call = $github->getUser('kelunik');
61 | $user = $call->execute();
62 | 
63 | var_dump($user->login);
64 | var_dump($user->avatarUrl);
65 | var_dump($user->name);
66 | 
67 | var_dump($call->getResponse()->getHeader('x-ratelimit-remaining'));


--------------------------------------------------------------------------------
/src/ServiceFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kelunik\Aerial;
 4 | 
 5 | use Amp\Http\Client\HttpClient;
 6 | use Amp\Serialization\Serializer;
 7 | use CuyZ\Valinor\Definition\Repository\Reflection\CombinedAttributesRepository;
 8 | use CuyZ\Valinor\Definition\Repository\Reflection\ReflectionFunctionDefinitionRepository;
 9 | use CuyZ\Valinor\Mapper\TreeMapper;
10 | use CuyZ\Valinor\MapperBuilder;
11 | use CuyZ\Valinor\Type\Parser\Factory\LexingTypeParserFactory;
12 | use CuyZ\Valinor\Type\Parser\Template\BasicTemplateParser;
13 | use Kelunik\Aerial\Internal\Service;
14 | use Kelunik\Aerial\Internal\ServiceCall;
15 | use ProxyManager\Factory\LazyLoadingValueHolderFactory;
16 | 
17 | final class ServiceFactory
18 | {
19 |     private ReflectionFunctionDefinitionRepository $reflection;
20 | 
21 |     private LazyLoadingValueHolderFactory $proxyFactory;
22 | 
23 |     public function __construct(
24 |         private HttpClient $httpClient,
25 |         private Serializer $serializer,
26 |         private ?TreeMapper $mapper = null
27 |     ) {
28 |         $this->mapper ??= (new MapperBuilder())->flexible()->mapper();
29 | 
30 |         $this->reflection = new ReflectionFunctionDefinitionRepository(
31 |             new LexingTypeParserFactory(new BasicTemplateParser()),
32 |             new CombinedAttributesRepository()
33 |         );
34 | 
35 |         $this->proxyFactory = new LazyLoadingValueHolderFactory();
36 |     }
37 | 
38 |     public function build(string $class): object
39 |     {
40 |         return $this->proxyFactory->createProxy(
41 |             $class,
42 |             function (&$wrappedObject, $proxy, $method, $parameters, &$initializer) use ($class) {
43 |                 $methods = [];
44 | 
45 |                 $reflectionClass = new \ReflectionClass($class);
46 |                 foreach ($reflectionClass->getMethods() as $method) {
47 |                     $definition = $this->reflection->for($method->getClosure($proxy));
48 |                     $methods[\strtolower($method->getName())] = new ServiceCall($definition, $this->httpClient, $this->serializer, $this->mapper);
49 |                 }
50 | 
51 |                 $wrappedObject = new Service($methods);
52 |                 $initializer = null; // turning off further lazy initialization
53 | 
54 |                 return true; // report success
55 |             }
56 |         );
57 |     }
58 | }


--------------------------------------------------------------------------------
/src/Internal/ServiceCall.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Kelunik\Aerial\Internal;
  4 | 
  5 | use Amp\Cancellation;
  6 | use Amp\Http\Client\Body\FormBody;
  7 | use Amp\Http\Client\HttpClient;
  8 | use Amp\Http\Client\Request;
  9 | use Amp\Http\Client\RequestBody;
 10 | use Amp\Http\Client\Response;
 11 | use Amp\Serialization\Serializer;
 12 | use CuyZ\Valinor\Definition\FunctionDefinition;
 13 | use CuyZ\Valinor\Definition\ParameterDefinition;
 14 | use CuyZ\Valinor\Mapper\TreeMapper;
 15 | use CuyZ\Valinor\Type\Type;
 16 | use CuyZ\Valinor\Type\Types\InterfaceType;
 17 | use CuyZ\Valinor\Type\Types\UnresolvableType;
 18 | use Kelunik\Aerial\Call;
 19 | use Kelunik\Aerial\Http\Body;
 20 | use Kelunik\Aerial\Http\FieldValue;
 21 | use Kelunik\Aerial\Http\Header;
 22 | use Kelunik\Aerial\Http\HeaderValue;
 23 | use Kelunik\Aerial\Http\HTTP;
 24 | use Kelunik\Aerial\ServiceException;
 25 | use League\Uri\UriTemplate;
 26 | 
 27 | /** @internal */
 28 | final class ServiceCall implements Call
 29 | {
 30 |     private string $requestMethod;
 31 |     private UriTemplate $uriTemplate;
 32 | 
 33 |     private Type $bodyType;
 34 | 
 35 |     /** @var Header[] */
 36 |     private array $staticHeaders = [];
 37 | 
 38 |     private array $templateArguments = [];
 39 | 
 40 |     /** @var Header[] */
 41 |     private array $dynamicHeaders = [];
 42 | 
 43 |     private ?RequestBody $requestBody = null;
 44 | 
 45 |     private ?Request $request = null;
 46 |     private ?Response $response = null;
 47 | 
 48 |     public function __construct(
 49 |         private FunctionDefinition $definition,
 50 |         private HttpClient $httpClient,
 51 |         private Serializer $serializer,
 52 |         private TreeMapper $mapper,
 53 |     ) {
 54 |         $this->determineBodyType($this->definition->returnType());
 55 |         $this->determineRequestTarget();
 56 |         $this->determineHeaders();
 57 |     }
 58 | 
 59 |     private function determineBodyType(Type $returnType): void
 60 |     {
 61 |         if ($returnType instanceof UnresolvableType) {
 62 |             throw new \TypeError('Unresolvable type: ' . $returnType->getMessage());
 63 |         }
 64 | 
 65 |         if (!$returnType instanceof InterfaceType) {
 66 |             throw new \TypeError('Invalid return type, expected Kelunik\\Aerial\\Call<T>, got ' . $returnType->toString());
 67 |         }
 68 | 
 69 |         if ($returnType->className() !== Call::class) {
 70 |             throw new \TypeError('Invalid return type, expected Kelunik\\Aerial\\Call<T>, got ' . $returnType->toString());
 71 |         }
 72 | 
 73 |         $this->bodyType = $returnType->generics()['T'];
 74 |     }
 75 | 
 76 |     private function determineRequestTarget()
 77 |     {
 78 |         $http = self::attribute($this->definition, HTTP::class);
 79 |         if (!$http) {
 80 |             throw new ServiceException('Missing #[HTTP] attribute on ' . $this->definition->signature());
 81 |         }
 82 | 
 83 |         $this->requestMethod = $http->getMethod();
 84 |         $this->uriTemplate = new UriTemplate($http->getUri());
 85 |     }
 86 | 
 87 |     private static function attribute(
 88 |         ParameterDefinition|FunctionDefinition $definition,
 89 |         string $attributeClass
 90 |     ): ?object {
 91 |         if (!$definition->attributes()->has($attributeClass)) {
 92 |             return null;
 93 |         }
 94 | 
 95 |         $attributes = $definition->attributes()->ofType($attributeClass);
 96 |         if (\count($attributes) !== 1) {
 97 |             throw new ServiceException(\sprintf(
 98 |                 'Invalid parameter %s, expected exactly one %s attribute',
 99 |                 $definition->signature(),
100 |                 $attributeClass,
101 |             ));
102 |         }
103 | 
104 |         return $attributes[0];
105 |     }
106 | 
107 |     private function determineHeaders()
108 |     {
109 |         $headers = $this->definition->attributes()->ofType(Header::class);
110 |         foreach ($headers as $header) {
111 |             $this->staticHeaders[] = $header;
112 |         }
113 |     }
114 | 
115 |     public function __clone(): void
116 |     {
117 |         $this->request = null;
118 |         $this->response = null;
119 |     }
120 | 
121 |     public function withArguments(array $arguments): self
122 |     {
123 |         $clone = clone $this;
124 |         $clone->templateArguments = [];
125 |         $clone->dynamicHeaders = [];
126 |         $clone->requestBody = null;
127 | 
128 |         $formFields = [];
129 | 
130 |         $parameters = $clone->definition->parameters();
131 |         foreach ($arguments as $key => $argument) {
132 |             if (\is_numeric($key)) {
133 |                 $param = $parameters->at($key);
134 |             } else {
135 |                 $param = $parameters->get($key);
136 |             }
137 | 
138 |             if (self::attribute($param, Body::class)) {
139 |                 if (!$argument instanceof RequestBody) {
140 |                     throw new ServiceException(\sprintf(
141 |                         'Invalid argument type for #[Body] parameter (%s), must be %s',
142 |                         $param->signature(),
143 |                         RequestBody::class,
144 |                     ));
145 |                 }
146 | 
147 |                 if ($clone->requestBody !== null) {
148 |                     throw new ServiceException(
149 |                         'Duplicate request body, do you have multiple parameters with the #[Body] attribute?'
150 |                     );
151 |                 }
152 | 
153 |                 $clone->requestBody = $argument;
154 |             } else if ($attribute = self::attribute($param, HeaderValue::class)) {
155 |                 if (!\is_string($argument)) {
156 |                     throw new ServiceException(\sprintf(
157 |                         'Invalid argument type for #[HeaderValue] parameter (%s), must be string',
158 |                         $param->signature(),
159 |                     ));
160 |                 }
161 | 
162 |                 $clone->dynamicHeaders[] = new Header($attribute->getName(), $argument);
163 |             } else if ($attribute = self::attribute($param, FieldValue::class)) {
164 |                 if (!\is_string($argument)) {
165 |                     throw new ServiceException(\sprintf(
166 |                         'Invalid argument type for #[Field] parameter (%s), must be string',
167 |                         $param->signature(),
168 |                     ));
169 |                 }
170 | 
171 |                 // Temporarily store in a variable,
172 |                 // so we can set these fields on a custom FormBody instance set in another parameter.
173 |                 $formFields[] = [$attribute->getName(), $argument];
174 |             } else {
175 |                 $clone->templateArguments[$param->name()] = $argument;
176 |             }
177 |         }
178 | 
179 |         if ($formFields) {
180 |             $clone->requestBody ??= new FormBody();
181 |             if (!$clone->requestBody instanceof FormBody) {
182 |                 throw new ServiceException(
183 |                     'Unable to set form field parameter due to a custom request body'
184 |                 );
185 |             }
186 | 
187 |             foreach ($formFields as [$name, $value]) {
188 |                 $clone->requestBody->addField($name, $value);
189 |             }
190 |         }
191 | 
192 |         $variableNames = $clone->uriTemplate->getVariableNames();
193 |         foreach ($variableNames as $variableName) {
194 |             if (!\array_key_exists($variableName, $clone->templateArguments)) {
195 |                 throw new ServiceException(\sprintf(
196 |                     'Missing parameter $%s for variable expansion in %s at %s',
197 |                     $variableName,
198 |                     $clone->uriTemplate->getTemplate(),
199 |                     $clone->definition->signature(),
200 |                 ));
201 |             }
202 |         }
203 | 
204 |         foreach ($clone->templateArguments as $name => $value) {
205 |             if (!\in_array($name, $variableNames)) {
206 |                 throw new ServiceException(\sprintf(
207 |                     'Parameter $%s isn\'t used in the URI template nor has any special attribute indicating its use at %s',
208 |                     $name,
209 |                     $clone->definition->signature(),
210 |                 ));
211 |             }
212 |         }
213 | 
214 |         return $clone;
215 |     }
216 | 
217 |     public function execute(?Cancellation $cancellation = null): mixed
218 |     {
219 |         $uri = $this->uriTemplate->expand($this->templateArguments);
220 |         $this->request = new Request($uri, $this->requestMethod);
221 | 
222 |         foreach ($this->staticHeaders as $header) {
223 |             $this->request->addHeader($header->getName(), $header->getValue());
224 |         }
225 | 
226 |         foreach ($this->dynamicHeaders as $header) {
227 |             $this->request->addHeader($header->getName(), $header->getValue());
228 |         }
229 | 
230 |         $this->response = $this->httpClient->request($this->request, $cancellation);
231 |         $responseBody = $this->response->getBody()->buffer();
232 | 
233 |         return $this->mapper->map($this->bodyType->toString(), $this->serializer->unserialize($responseBody));
234 |     }
235 | 
236 |     public function getRequest(): Request
237 |     {
238 |         return $this->request ?? throw new ServiceException('Request is not available yet, ensure execute() has been called.');
239 |     }
240 | 
241 |     public function getResponse(): Response
242 |     {
243 |         return $this->response ?? throw new ServiceException('Response is not available yet, ensure execute() has been called.');
244 |     }
245 | }


--------------------------------------------------------------------------------