mirror of
https://github.com/symfony/http-kernel.git
synced 2026-03-24 01:12:09 +01:00
47bc33d92b
This PR was merged into the 8.1 branch.
Discussion
----------
[HttpKernel] Add option to map empty data with `MapQueryString` and `MapRequestPayload`
| Q | A
| ------------- | ---
| Branch? | 8.1
| Bug fix? | no
| New feature? | yes
| Deprecations? | no
| Issues | -
| License | MIT
When `#[MapQueryString]` or `#[MapRequestPayload]` is used on a nullable/default-valued parameter and the query string or request body is empty, the resolver short-circuits and returns `null` without ever calling the serializer. This prevents custom denormalizers from constructing the object.
This PR adds `bool $mapWhenEmpty = false` to both attributes. When `true`, the resolver passes `[]` to `denormalize()` even when no data is present, giving custom denormalizers a chance to populate the DTO.
```php
public function __construct(
#[MapRequestPayload(mapWhenEmpty: true)] SearchFilters $filters,
) {}
```
**Use case:** a DTO where some fields come from the request and others are injected by a custom denormalizer (e.g. from the security context or session):
```php
class SearchFilters {
public function __construct(
public ?string $keyword = null, // from query string
public int $userId = 0, // set by a custom denormalizer
) {}
}
```
Without `mapWhenEmpty`, an empty query string yields `null`, the denormalizer never runs. With `mapWhenEmpty: true`, denormalization proceeds and the custom denormalizer can populate `$userId`.
Commits
-------
5117bb6f178 [HttpKernel] Add argument `$mapWhenEmpty` to `MapQueryString` and `MapRequestPayload` for always attempting denormalization with empty query and request payload
349 lines
16 KiB
PHP
349 lines
16 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of the Symfony package.
|
|
*
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Symfony\Component\HttpKernel\Controller\ArgumentResolver;
|
|
|
|
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
|
|
use Symfony\Component\ExpressionLanguage\Expression;
|
|
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
|
|
use Symfony\Component\HttpFoundation\File\UploadedFile;
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
use Symfony\Component\HttpKernel\Attribute\MapQueryString;
|
|
use Symfony\Component\HttpKernel\Attribute\MapRequestPayload;
|
|
use Symfony\Component\HttpKernel\Attribute\MapUploadedFile;
|
|
use Symfony\Component\HttpKernel\Controller\ValueResolverInterface;
|
|
use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
|
|
use Symfony\Component\HttpKernel\Event\ControllerArgumentsEvent;
|
|
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
|
|
use Symfony\Component\HttpKernel\Exception\HttpException;
|
|
use Symfony\Component\HttpKernel\Exception\NearMissValueResolverException;
|
|
use Symfony\Component\HttpKernel\Exception\UnsupportedMediaTypeHttpException;
|
|
use Symfony\Component\HttpKernel\KernelEvents;
|
|
use Symfony\Component\Serializer\Exception\InvalidArgumentException as SerializerInvalidArgumentException;
|
|
use Symfony\Component\Serializer\Exception\NotEncodableValueException;
|
|
use Symfony\Component\Serializer\Exception\PartialDenormalizationException;
|
|
use Symfony\Component\Serializer\Exception\UnexpectedPropertyException;
|
|
use Symfony\Component\Serializer\Exception\UnsupportedFormatException;
|
|
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
|
|
use Symfony\Component\Serializer\SerializerInterface;
|
|
use Symfony\Component\Validator\Constraints as Assert;
|
|
use Symfony\Component\Validator\Constraints\GroupSequence;
|
|
use Symfony\Component\Validator\ConstraintViolation;
|
|
use Symfony\Component\Validator\ConstraintViolationList;
|
|
use Symfony\Component\Validator\Exception\ValidationFailedException;
|
|
use Symfony\Component\Validator\Validator\ValidatorInterface;
|
|
use Symfony\Contracts\Translation\TranslatorInterface;
|
|
|
|
/**
|
|
* @author Konstantin Myakshin <molodchick@gmail.com>
|
|
*
|
|
* @psalm-type GroupResolver = \Closure(array<string, mixed>, Request, ?object):string|GroupSequence|array<string>
|
|
*
|
|
* @final
|
|
*/
|
|
class RequestPayloadValueResolver implements ValueResolverInterface, EventSubscriberInterface
|
|
{
|
|
/**
|
|
* @see DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS
|
|
*/
|
|
private const CONTEXT_DENORMALIZE = [
|
|
'collect_denormalization_errors' => true,
|
|
];
|
|
|
|
/**
|
|
* @see DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS
|
|
*/
|
|
private const CONTEXT_DESERIALIZE = [
|
|
'collect_denormalization_errors' => true,
|
|
];
|
|
|
|
public function __construct(
|
|
private readonly SerializerInterface&DenormalizerInterface $serializer,
|
|
private readonly ?ValidatorInterface $validator = null,
|
|
private readonly ?TranslatorInterface $translator = null,
|
|
private string $translationDomain = 'validators',
|
|
private ?ExpressionLanguage $expressionLanguage = null,
|
|
) {
|
|
}
|
|
|
|
public function resolve(Request $request, ArgumentMetadata $argument): iterable
|
|
{
|
|
$attribute = $argument->getAttributesOfType(MapQueryString::class, ArgumentMetadata::IS_INSTANCEOF)[0]
|
|
?? $argument->getAttributesOfType(MapRequestPayload::class, ArgumentMetadata::IS_INSTANCEOF)[0]
|
|
?? $argument->getAttributesOfType(MapUploadedFile::class, ArgumentMetadata::IS_INSTANCEOF)[0]
|
|
?? null;
|
|
|
|
if (!$attribute) {
|
|
return [];
|
|
}
|
|
|
|
if ($attribute instanceof MapQueryString && $argument->isVariadic()) {
|
|
throw new \LogicException(\sprintf('Mapping variadic argument "$%s" is not supported.', $argument->getName()));
|
|
}
|
|
|
|
if ($attribute instanceof MapRequestPayload) {
|
|
if ('array' === $argument->getType()) {
|
|
if (!$attribute->type) {
|
|
throw new NearMissValueResolverException(\sprintf('Please set the $type argument of the #[%s] attribute to the type of the objects in the expected array.', MapRequestPayload::class));
|
|
}
|
|
} elseif ($attribute->type && !$argument->isVariadic()) {
|
|
throw new NearMissValueResolverException(\sprintf('Please set its type to "array" when using argument $type of #[%s].', MapRequestPayload::class));
|
|
}
|
|
}
|
|
|
|
$attribute->metadata = $argument;
|
|
|
|
return [$attribute];
|
|
}
|
|
|
|
public function onKernelControllerArguments(ControllerArgumentsEvent $event): void
|
|
{
|
|
$arguments = $event->getArguments();
|
|
|
|
foreach ($arguments as $i => $argument) {
|
|
if ($argument instanceof MapQueryString) {
|
|
$payloadMapper = $this->mapQueryString(...);
|
|
$validationFailedCode = $argument->validationFailedStatusCode;
|
|
} elseif ($argument instanceof MapRequestPayload) {
|
|
$payloadMapper = $this->mapRequestPayload(...);
|
|
$validationFailedCode = $argument->validationFailedStatusCode;
|
|
} elseif ($argument instanceof MapUploadedFile) {
|
|
$payloadMapper = $this->mapUploadedFile(...);
|
|
$validationFailedCode = $argument->validationFailedStatusCode;
|
|
} else {
|
|
continue;
|
|
}
|
|
$request = $event->getRequest();
|
|
|
|
if (!$argument->metadata->getType()) {
|
|
throw new \LogicException(\sprintf('Could not resolve the "$%s" controller argument: argument should be typed.', $argument->metadata->getName()));
|
|
}
|
|
|
|
if ($this->validator) {
|
|
$violations = new ConstraintViolationList();
|
|
try {
|
|
$payload = $payloadMapper($request, $argument->metadata, $argument);
|
|
} catch (PartialDenormalizationException $e) {
|
|
$trans = $this->translator ? $this->translator->trans(...) : static fn ($m, $p) => strtr($m, $p);
|
|
foreach ($e->getErrors() as $error) {
|
|
$parameters = [];
|
|
$template = 'This value was of an unexpected type.';
|
|
if ($expectedTypes = $error->getExpectedTypes()) {
|
|
$template = 'This value should be of type {{ type }}.';
|
|
$parameters['{{ type }}'] = implode('|', $expectedTypes);
|
|
}
|
|
if ($error->canUseMessageForUser()) {
|
|
$parameters['hint'] = $error->getMessage();
|
|
}
|
|
$message = $trans($template, $parameters, $this->translationDomain);
|
|
$violations->add(new ConstraintViolation($message, $template, $parameters, null, $error->getPath(), null));
|
|
}
|
|
$payload = $e->getData();
|
|
} catch (SerializerInvalidArgumentException $e) {
|
|
$violations->add(new ConstraintViolation($e->getMessage(), $e->getMessage(), [], null, '', null));
|
|
$payload = null;
|
|
}
|
|
|
|
if (null !== $payload && !\count($violations)) {
|
|
$constraints = $argument->constraints ?? null;
|
|
if (\is_array($payload) && !empty($constraints) && !$constraints instanceof Assert\All) {
|
|
$constraints = new Assert\All($constraints);
|
|
}
|
|
$groups = $this->resolveValidationGroups($argument->validationGroups ?? null, $event);
|
|
|
|
if ($argument instanceof MapUploadedFile) {
|
|
$violations->addAll($this->validator->startContext()->atPath($argument->metadata->getName())->validate($payload, $constraints, $groups)->getViolations());
|
|
} else {
|
|
$violations->addAll($this->validator->validate($payload, $constraints, $groups));
|
|
}
|
|
}
|
|
|
|
if (\count($violations)) {
|
|
throw HttpException::fromStatusCode($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), iterator_to_array($violations))), new ValidationFailedException($payload, $violations));
|
|
}
|
|
} else {
|
|
try {
|
|
$payload = $payloadMapper($request, $argument->metadata, $argument);
|
|
} catch (PartialDenormalizationException $e) {
|
|
throw HttpException::fromStatusCode($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), $e->getErrors())), $e);
|
|
} catch (SerializerInvalidArgumentException $e) {
|
|
throw HttpException::fromStatusCode($validationFailedCode, $e->getMessage(), $e);
|
|
}
|
|
}
|
|
|
|
if ($argument->metadata->isVariadic()) {
|
|
array_splice($arguments, $i, 1, $payload ?? []);
|
|
continue;
|
|
}
|
|
|
|
if (null === $payload) {
|
|
$payload = match (true) {
|
|
$argument->metadata->hasDefaultValue() => $argument->metadata->getDefaultValue(),
|
|
$argument->metadata->isNullable() => null,
|
|
default => throw HttpException::fromStatusCode($validationFailedCode),
|
|
};
|
|
}
|
|
|
|
$arguments[$i] = $payload;
|
|
}
|
|
|
|
$event->setArguments($arguments);
|
|
}
|
|
|
|
public static function getSubscribedEvents(): array
|
|
{
|
|
return [
|
|
KernelEvents::CONTROLLER_ARGUMENTS => 'onKernelControllerArguments',
|
|
];
|
|
}
|
|
|
|
private function mapQueryString(Request $request, ArgumentMetadata $argument, MapQueryString $attribute): ?object
|
|
{
|
|
if (!($data = $request->query->all($attribute->key)) && ($argument->isNullable() || $argument->hasDefaultValue()) && !$attribute->mapWhenEmpty) {
|
|
return null;
|
|
}
|
|
|
|
return $this->serializer->denormalize($data, $argument->getType(), 'csv', $attribute->serializationContext + self::CONTEXT_DENORMALIZE + ['filter_bool' => true]);
|
|
}
|
|
|
|
private function mapRequestPayload(Request $request, ArgumentMetadata $argument, MapRequestPayload $attribute): object|array|null
|
|
{
|
|
if ('' === $data = $request->request->all() ?: $request->getContent()) {
|
|
if ($attribute->mapWhenEmpty) {
|
|
$data = [];
|
|
} elseif ($argument->isNullable() || $argument->hasDefaultValue()) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (null === $format = $request->getContentTypeFormat()) {
|
|
throw new UnsupportedMediaTypeHttpException('Unsupported format.');
|
|
}
|
|
|
|
if ($attribute->acceptFormat && !\in_array($format, (array) $attribute->acceptFormat, true)) {
|
|
throw new UnsupportedMediaTypeHttpException(\sprintf('Unsupported format, expects "%s", but "%s" given.', implode('", "', (array) $attribute->acceptFormat), $format));
|
|
}
|
|
|
|
$type = match (true) {
|
|
$argument->isVariadic() => ($attribute->type ?? $argument->getType()).'[]',
|
|
'array' === $argument->getType() && null !== $attribute->type => $attribute->type.'[]',
|
|
default => $argument->getType(),
|
|
};
|
|
|
|
if (\is_array($data)) {
|
|
$data = $this->mergeParamsAndFiles($data, $request->files->all());
|
|
|
|
return $this->serializer->denormalize($data, $type, self::hasNonStringScalar($data) ? $format : 'csv', $attribute->serializationContext + self::CONTEXT_DENORMALIZE + ('form' === $format ? ['filter_bool' => true] : []));
|
|
}
|
|
|
|
if ('form' === $format) {
|
|
throw new BadRequestHttpException('Request payload contains invalid "form" data.');
|
|
}
|
|
|
|
try {
|
|
return $this->serializer->deserialize($data, $type, $format, self::CONTEXT_DESERIALIZE + $attribute->serializationContext);
|
|
} catch (UnsupportedFormatException $e) {
|
|
throw new UnsupportedMediaTypeHttpException(\sprintf('Unsupported format: "%s".', $format), $e);
|
|
} catch (NotEncodableValueException $e) {
|
|
throw new BadRequestHttpException(\sprintf('Request payload contains invalid "%s" data.', $format), $e);
|
|
} catch (UnexpectedPropertyException $e) {
|
|
throw new BadRequestHttpException(\sprintf('Request payload contains invalid "%s" property.', $e->property), $e);
|
|
}
|
|
}
|
|
|
|
private function mapUploadedFile(Request $request, ArgumentMetadata $argument, MapUploadedFile $attribute): UploadedFile|array|null
|
|
{
|
|
if ($files = $request->files->get($attribute->name ?? $argument->getName())) {
|
|
return !\is_array($files) && $argument->isVariadic() ? [$files] : $files;
|
|
}
|
|
|
|
if ($argument->isNullable() || $argument->hasDefaultValue()) {
|
|
return null;
|
|
}
|
|
|
|
return 'array' === $argument->getType() ? [] : null;
|
|
}
|
|
|
|
private function mergeParamsAndFiles(array $params, array $files): array
|
|
{
|
|
$isFilesList = array_is_list($files);
|
|
|
|
foreach ($params as $key => $value) {
|
|
if (\is_array($value) && \is_array($files[$key] ?? null)) {
|
|
$params[$key] = $this->mergeParamsAndFiles($value, $files[$key]);
|
|
unset($files[$key]);
|
|
}
|
|
}
|
|
|
|
if (!$isFilesList) {
|
|
return array_replace($params, $files);
|
|
}
|
|
|
|
foreach ($files as $value) {
|
|
$params[] = $value;
|
|
}
|
|
|
|
return $params;
|
|
}
|
|
|
|
private function resolveValidationGroups(Expression|string|GroupSequence|\Closure|array|null $validationGroups, ControllerArgumentsEvent $event): string|GroupSequence|array|null
|
|
{
|
|
if ($validationGroups instanceof Expression || $validationGroups instanceof \Closure) {
|
|
$validationGroups = $event->evaluate($validationGroups, $this->expressionLanguage);
|
|
}
|
|
|
|
if (null === $validationGroups || \is_string($validationGroups) || $validationGroups instanceof GroupSequence) {
|
|
return $validationGroups;
|
|
}
|
|
|
|
if (!\is_array($validationGroups)) {
|
|
throw new \LogicException('The validation groups expression or closure must return a string, an array of strings, or a GroupSequence.');
|
|
}
|
|
|
|
foreach ($validationGroups as $group) {
|
|
if ($group instanceof Expression) {
|
|
throw new \LogicException('Nested expressions in validation groups are not supported. Use a single Expression or a list of strings (or a GroupSequence) instead.');
|
|
}
|
|
|
|
if ($group instanceof \Closure) {
|
|
throw new \LogicException('Nested closures in validation groups are not supported. Use a single Closure or a list of strings (or a GroupSequence) instead.');
|
|
}
|
|
|
|
if ($group instanceof GroupSequence) {
|
|
throw new \LogicException('GroupSequence cannot be used inside an array of validation groups. Pass the GroupSequence as the top-level validationGroups value instead.');
|
|
}
|
|
|
|
if (!\is_string($group)) {
|
|
throw new \LogicException('Validation groups must be strings.');
|
|
}
|
|
}
|
|
|
|
return $validationGroups;
|
|
}
|
|
|
|
private static function hasNonStringScalar(array $data): bool
|
|
{
|
|
$stack = [$data];
|
|
|
|
while ($stack) {
|
|
foreach (array_pop($stack) as $v) {
|
|
if (\is_array($v)) {
|
|
$stack[] = $v;
|
|
} elseif (!\is_string($v)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|