9300200197

Committed 30 May 2024 09:24AM UTC coverage: 57.421% (-0.1%) from 57.535%

Build # 9300200197

Build Type

push

github

Committed by

web-flow

Commit Message

fix(graphql): name converter with class (#6396)

* fix(graphql): name converter with class

see https://github.com/symfony/symfony/commit/d088047df

* fix(serializer): metadata name converter bc layer

Run Details

1 of 4 new or added lines in 4 files covered. (25.0%)

21 existing lines in 7 files now uncovered.

10036 of 17478 relevant lines covered (57.42%)

48.65 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.13

/src/Symfony/EventListener/AddFormatListener.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ApiPlatform\Symfony\EventListener;

use ApiPlatform\Api\FormatMatcher;
use ApiPlatform\Metadata\Error as ErrorOperation;
use ApiPlatform\Metadata\HttpOperation;
use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
use ApiPlatform\State\ProviderInterface;
use ApiPlatform\State\Util\OperationRequestInitiatorTrait;
use ApiPlatform\Symfony\Util\RequestAttributesExtractor;
use Negotiation\Exception\InvalidArgument;
use Negotiation\Negotiator;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

/**
 * Chooses the format to use according to the Accept header and supported formats.
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 */
final class AddFormatListener
{
    use OperationRequestInitiatorTrait;

    private ?Negotiator $negotiator;
    private ?ProviderInterface $provider = null;

    /**
     * @param ProviderInterface|Negotiator $negotiator
     */
    public function __construct($negotiator, ?ResourceMetadataCollectionFactoryInterface $resourceMetadataCollectionFactory = null, private readonly array $formats = [], private readonly array $errorFormats = [], private readonly array $docsFormats = [], private readonly ?bool $eventsBackwardCompatibility = null) // @phpstan-ignore-line
    {
        if ($negotiator instanceof ProviderInterface) {
            $this->provider = $negotiator;
        } else {
            trigger_deprecation('api-platform/core', '3.3', 'Use a "%s" as first argument in "%s" instead of "%s".', ProviderInterface::class, self::class, Negotiator::class);
            $this->negotiator = $negotiator;
        }

        $this->resourceMetadataCollectionFactory = $resourceMetadataCollectionFactory;
    }

    /**
     * Sets the applicable format to the HttpFoundation Request.
     *
     * @throws NotFoundHttpException
     * @throws NotAcceptableHttpException
     */
    public function onKernelRequest(RequestEvent $event): void
    {
        $request = $event->getRequest();
        $operation = $this->initializeOperation($request);

        // TODO: legacy code
        if ($request->attributes->get('_api_exception_action')) {
            return;
        }

        $attributes = RequestAttributesExtractor::extractAttributes($request);
        if (!($attributes['respond'] ?? $request->attributes->getBoolean('_api_respond'))) {
            return;
        }

        if ($operation && $this->provider) {
            $this->provider->provide($operation, $request->attributes->get('_api_uri_variables') ?? [], [
                'request' => $request,
                'uri_variables' => $request->attributes->get('_api_uri_variables') ?? [],
                'resource_class' => $operation->getClass(),
            ]);

            return;
        }

        // TODO: the code below needs to be removed in 4.x
        if ($this->provider && !$operation) {
            return;
        }

        if ('api_platform.action.entrypoint' === $request->attributes->get('_controller')) {
            return;
        }

        if ('api_platform.symfony.main_controller' === $operation?->getController() || $request->attributes->get('_api_platform_disable_listeners')) {
            return;
        }

        if ($operation instanceof ErrorOperation) {
            return;
        }

        if (!(
            $request->attributes->has('_api_resource_class')
            || $request->attributes->getBoolean('_api_respond', false)
            || $request->attributes->getBoolean('_graphql', false)
        )) {
            return;
        }

        $formats = $operation?->getOutputFormats() ?? ('api_doc' === $request->attributes->get('_route') ? $this->docsFormats : $this->formats);

        $this->addRequestFormats($request, $formats);

        // Empty strings must be converted to null because the Symfony router doesn't support parameter typing before 3.2 (_format)
        if (null === $routeFormat = $request->attributes->get('_format') ?: null) {
            $flattenedMimeTypes = $this->flattenMimeTypes($formats);
            $mimeTypes = array_keys($flattenedMimeTypes);
        } elseif (!isset($formats[$routeFormat])) {
            if (!$request->attributes->get('data') instanceof \Exception) {
                throw new NotFoundHttpException(sprintf('Format "%s" is not supported', $routeFormat));
            }
            $this->setRequestErrorFormat($operation, $request);

            return;
        } else {
            $mimeTypes = Request::getMimeTypes($routeFormat);
            $flattenedMimeTypes = $this->flattenMimeTypes([$routeFormat => $mimeTypes]);
        }

        // First, try to guess the format from the Accept header
        /** @var string|null $accept */
        $accept = $request->headers->get('Accept');

        if (null !== $accept) {
            $mediaType = null;
            try {
                $mediaType = $this->negotiator->getBest($accept, $mimeTypes);
            } catch (InvalidArgument) {
                throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);
            }

            if (null === $mediaType) {
                if (!$request->attributes->get('data') instanceof \Exception) {
                    throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);
                }

                $this->setRequestErrorFormat($operation, $request);

                return;
            }
            $formatMatcher = new FormatMatcher($formats);
            $request->setRequestFormat($formatMatcher->getFormat($mediaType->getType()));

            return;
        }

        // Then use the Symfony request format if available and applicable
        $requestFormat = $request->getRequestFormat('') ?: null;
        if (null !== $requestFormat) {
            $mimeType = $request->getMimeType($requestFormat);

            if (isset($flattenedMimeTypes[$mimeType])) {
                return;
            }

            if ($request->attributes->get('data') instanceof \Exception) {
                $this->setRequestErrorFormat($operation, $request);

                return;
            }

            throw $this->getNotAcceptableHttpException($mimeType, $flattenedMimeTypes);
        }

        // Finally, if no Accept header nor Symfony request format is set, return the default format
        foreach ($formats as $format => $mimeType) {
            $request->setRequestFormat($format);

            return;
        }
    }

    /**
     * Adds the supported formats to the request.
     *
     * This is necessary for {@see Request::getMimeType} and {@see Request::getMimeTypes} to work.
     */
    private function addRequestFormats(Request $request, array $formats): void
    {
        foreach ($formats as $format => $mimeTypes) {
            $request->setFormat($format, (array) $mimeTypes);
        }
    }

    /**
     * Retries the flattened list of MIME types.
     */
    private function flattenMimeTypes(array $formats): array
    {
        $flattenedMimeTypes = [];
        foreach ($formats as $format => $mimeTypes) {
            foreach ($mimeTypes as $mimeType) {
                $flattenedMimeTypes[$mimeType] = $format;
            }
        }

        return $flattenedMimeTypes;
    }

    /**
     * Retrieves an instance of NotAcceptableHttpException.
     */
    private function getNotAcceptableHttpException(string $accept, array $mimeTypes): NotAcceptableHttpException
    {
        return new NotAcceptableHttpException(sprintf(
            'Requested format "%s" is not supported. Supported MIME types are "%s".',
            $accept,
            implode('", "', array_keys($mimeTypes))
        ));
    }

    public function setRequestErrorFormat(?HttpOperation $operation, Request $request): void
    {
        $errorResourceFormats = array_merge($operation?->getOutputFormats() ?? [], $operation?->getFormats() ?? [], $this->errorFormats);

        $flattened = $this->flattenMimeTypes($errorResourceFormats);
        if ($flattened[$accept = $request->headers->get('Accept')] ?? false) {
            $request->setRequestFormat($flattened[$accept]);

            return;
        }

        if (isset($errorResourceFormats['jsonproblem'])) {
            $request->setRequestFormat('jsonproblem');
            $request->setFormat('jsonproblem', $errorResourceFormats['jsonproblem']);

            return;
        }

        $request->setRequestFormat(array_key_first($errorResourceFormats));
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Symfony\EventListener;
15
16	use ApiPlatform\Api\FormatMatcher;
17	use ApiPlatform\Metadata\Error as ErrorOperation;
18	use ApiPlatform\Metadata\HttpOperation;
19	use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
20	use ApiPlatform\State\ProviderInterface;
21	use ApiPlatform\State\Util\OperationRequestInitiatorTrait;
22	use ApiPlatform\Symfony\Util\RequestAttributesExtractor;
23	use Negotiation\Exception\InvalidArgument;
24	use Negotiation\Negotiator;
25	use Symfony\Component\HttpFoundation\Request;
26	use Symfony\Component\HttpKernel\Event\RequestEvent;
27	use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
28	use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
29
30	/**
31	* Chooses the format to use according to the Accept header and supported formats.
32	*
33	* @author Kévin Dunglas <dunglas@gmail.com>
34	*/
35	final class AddFormatListener
36	{
37	use OperationRequestInitiatorTrait;
38
39	private ?Negotiator $negotiator;
40	private ?ProviderInterface $provider = null;
41
42	/**
43	* @param ProviderInterface\|Negotiator $negotiator
44	*/
45	public function __construct($negotiator, ?ResourceMetadataCollectionFactoryInterface $resourceMetadataCollectionFactory = null, private readonly array $formats = [], private readonly array $errorFormats = [], private readonly array $docsFormats = [], private readonly ?bool $eventsBackwardCompatibility = null) // @phpstan-ignore-line
46	{
47	if ($negotiator instanceof ProviderInterface) {	97✔
48	$this->provider = $negotiator;	×
49	} else {
50	trigger_deprecation('api-platform/core', '3.3', 'Use a "%s" as first argument in "%s" instead of "%s".', ProviderInterface::class, self::class, Negotiator::class);	97✔
51	$this->negotiator = $negotiator;	97✔
52	}
53
54	$this->resourceMetadataCollectionFactory = $resourceMetadataCollectionFactory;	97✔
55	}
56
57	/**
58	* Sets the applicable format to the HttpFoundation Request.
59	*
60	* @throws NotFoundHttpException
61	* @throws NotAcceptableHttpException
62	*/
63	public function onKernelRequest(RequestEvent $event): void
64	{
65	$request = $event->getRequest();	97✔
66	$operation = $this->initializeOperation($request);	97✔
67
68	// TODO: legacy code
69	if ($request->attributes->get('_api_exception_action')) {	97✔
UNCOV 70	return;	1✔
71	}
72
73	$attributes = RequestAttributesExtractor::extractAttributes($request);	97✔
74	if (!($attributes['respond'] ?? $request->attributes->getBoolean('_api_respond'))) {	97✔
75	return;	8✔
76	}
77
78	if ($operation && $this->provider) {	93✔
79	$this->provider->provide($operation, $request->attributes->get('_api_uri_variables') ?? [], [	×
80	'request' => $request,	×
81	'uri_variables' => $request->attributes->get('_api_uri_variables') ?? [],	×
82	'resource_class' => $operation->getClass(),	×
83	]);	×
84
85	return;	×
86	}
87
88	// TODO: the code below needs to be removed in 4.x
89	if ($this->provider && !$operation) {	93✔
90	return;	×
91	}
92
93	if ('api_platform.action.entrypoint' === $request->attributes->get('_controller')) {	93✔
UNCOV 94	return;	7✔
95	}
96
97	if ('api_platform.symfony.main_controller' === $operation?->getController() \|\| $request->attributes->get('_api_platform_disable_listeners')) {	86✔
UNCOV 98	return;	32✔
99	}
100
101	if ($operation instanceof ErrorOperation) {	54✔
102	return;	×
103	}
104
105	if (!(
106	$request->attributes->has('_api_resource_class')	54✔
107	\|\| $request->attributes->getBoolean('_api_respond', false)	54✔
108	\|\| $request->attributes->getBoolean('_graphql', false)	54✔
109	)) {
110	return;	×
111	}
112
113	$formats = $operation?->getOutputFormats() ?? ('api_doc' === $request->attributes->get('_route') ? $this->docsFormats : $this->formats);	54✔
114
115	$this->addRequestFormats($request, $formats);	54✔
116
117	// Empty strings must be converted to null because the Symfony router doesn't support parameter typing before 3.2 (_format)
118	if (null === $routeFormat = $request->attributes->get('_format') ?: null) {	54✔
119	$flattenedMimeTypes = $this->flattenMimeTypes($formats);	48✔
120	$mimeTypes = array_keys($flattenedMimeTypes);	48✔
121	} elseif (!isset($formats[$routeFormat])) {	6✔
122	if (!$request->attributes->get('data') instanceof \Exception) {	4✔
123	throw new NotFoundHttpException(sprintf('Format "%s" is not supported', $routeFormat));	4✔
124	}
125	$this->setRequestErrorFormat($operation, $request);	×
126
127	return;	×
128	} else {
UNCOV 129	$mimeTypes = Request::getMimeTypes($routeFormat);	2✔
UNCOV 130	$flattenedMimeTypes = $this->flattenMimeTypes([$routeFormat => $mimeTypes]);	2✔
131	}
132
133	// First, try to guess the format from the Accept header
134	/** @var string\|null $accept */
135	$accept = $request->headers->get('Accept');	50✔
136
137	if (null !== $accept) {	50✔
138	$mediaType = null;	34✔
139	try {
140	$mediaType = $this->negotiator->getBest($accept, $mimeTypes);	34✔
141	} catch (InvalidArgument) {	4✔
142	throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);	4✔
143	}
144
145	if (null === $mediaType) {	30✔
146	if (!$request->attributes->get('data') instanceof \Exception) {	12✔
147	throw $this->getNotAcceptableHttpException($accept, $flattenedMimeTypes);	12✔
148	}
149
150	$this->setRequestErrorFormat($operation, $request);	×
151
152	return;	×
153	}
154	$formatMatcher = new FormatMatcher($formats);	18✔
155	$request->setRequestFormat($formatMatcher->getFormat($mediaType->getType()));	18✔
156
157	return;	18✔
158	}
159
160	// Then use the Symfony request format if available and applicable
161	$requestFormat = $request->getRequestFormat('') ?: null;	16✔
162	if (null !== $requestFormat) {	16✔
163	$mimeType = $request->getMimeType($requestFormat);	16✔
164
165	if (isset($flattenedMimeTypes[$mimeType])) {	16✔
166	return;	12✔
167	}
168
169	if ($request->attributes->get('data') instanceof \Exception) {	4✔
170	$this->setRequestErrorFormat($operation, $request);	×
171
172	return;	×
173	}
174
175	throw $this->getNotAcceptableHttpException($mimeType, $flattenedMimeTypes);	4✔
176	}
177
178	// Finally, if no Accept header nor Symfony request format is set, return the default format
179	foreach ($formats as $format => $mimeType) {	×
180	$request->setRequestFormat($format);	×
181
182	return;	×
183	}
184	}
185
186	/**
187	* Adds the supported formats to the request.
188	*
189	* This is necessary for {@see Request::getMimeType} and {@see Request::getMimeTypes} to work.
190	*/
191	private function addRequestFormats(Request $request, array $formats): void
192	{
193	foreach ($formats as $format => $mimeTypes) {	54✔
194	$request->setFormat($format, (array) $mimeTypes);	54✔
195	}
196	}
197
198	/**
199	* Retries the flattened list of MIME types.
200	*/
201	private function flattenMimeTypes(array $formats): array
202	{
203	$flattenedMimeTypes = [];	50✔
204	foreach ($formats as $format => $mimeTypes) {	50✔
205	foreach ($mimeTypes as $mimeType) {	50✔
206	$flattenedMimeTypes[$mimeType] = $format;	50✔
207	}
208	}
209
210	return $flattenedMimeTypes;	50✔
211	}
212
213	/**
214	* Retrieves an instance of NotAcceptableHttpException.
215	*/
216	private function getNotAcceptableHttpException(string $accept, array $mimeTypes): NotAcceptableHttpException
217	{
218	return new NotAcceptableHttpException(sprintf(	20✔
219	'Requested format "%s" is not supported. Supported MIME types are "%s".',	20✔
220	$accept,	20✔
221	implode('", "', array_keys($mimeTypes))	20✔
222	));	20✔
223	}
224
225	public function setRequestErrorFormat(?HttpOperation $operation, Request $request): void
226	{
227	$errorResourceFormats = array_merge($operation?->getOutputFormats() ?? [], $operation?->getFormats() ?? [], $this->errorFormats);	×
228
229	$flattened = $this->flattenMimeTypes($errorResourceFormats);	×
230	if ($flattened[$accept = $request->headers->get('Accept')] ?? false) {	×
231	$request->setRequestFormat($flattened[$accept]);	×
232
233	return;	×
234	}
235
236	if (isset($errorResourceFormats['jsonproblem'])) {	×
237	$request->setRequestFormat('jsonproblem');	×
238	$request->setFormat('jsonproblem', $errorResourceFormats['jsonproblem']);	×
239
240	return;	×
241	}
242
243	$request->setRequestFormat(array_key_first($errorResourceFormats));	×
244	}
245	}

api-platform / core / 9300200197

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous