[HttpKernel] Enhance MapRequestPayload adding format and validation group

Renan · Renan · commit 30810f6f616b · 2023-04-16T16:31:04.000+02:00
diff --git a/src/Symfony/Component/HttpKernel/Attribute/MapRequestPayload.php b/src/Symfony/Component/HttpKernel/Attribute/MapRequestPayload.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\HttpKernel\Attribute;
 
 use Symfony\Component\HttpKernel\Controller\ArgumentResolver\RequestPayloadValueResolver;
+use Symfony\Component\Validator\Constraints\GroupSequence;
 
 /**
  * Controller parameter tag to map the request content to typed object and validate it.
@@ -22,7 +23,9 @@
 class MapRequestPayload extends ValueResolver
 {
     public function __construct(
+        public readonly array|string|null $format = null,
         public readonly array $context = [],
+        public readonly string|GroupSequence|array|null|false $groups = null,
         string $resolver = RequestPayloadValueResolver::class,
     ) {
         parent::__construct($resolver);
diff --git a/src/Symfony/Component/HttpKernel/Controller/ArgumentResolver/RequestPayloadValueResolver.php b/src/Symfony/Component/HttpKernel/Controller/ArgumentResolver/RequestPayloadValueResolver.php
@@ -69,14 +69,14 @@ public function resolve(Request $request, ArgumentMetadata $argument): iterable
                 continue;
             }
 
-            if (!$type = $argument->getType()) {
+            if (!$argument->getType()) {
                 throw new \LogicException(sprintf('Could not resolve the "$%s" controller argument: argument should be typed.', $argument->getName()));
             }
 
             if ($this->validator) {
                 $violations = new ConstraintViolationList();
                 try {
-                    $payload = $this->$payloadMapper($request, $type, $attributes[0]);
+                    $payload = $this->$payloadMapper($request, $argument, $attributes[0]);
                 } catch (PartialDenormalizationException $e) {
                     $trans = $this->translator ? $this->translator->trans(...) : fn ($m, $p) => strtr($m, $p);
                     foreach ($e->getErrors() as $error) {
@@ -92,15 +92,15 @@ public function resolve(Request $request, ArgumentMetadata $argument): iterable
                 }
 
                 if (null !== $payload) {
-                    $violations->addAll($this->validator->validate($payload));
+                    $violations->addAll($this->validator->validate($payload, null, $attributes[0]->groups ?? null));
                 }
 
                 if (\count($violations)) {
                     throw new HttpException($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), iterator_to_array($violations))), new ValidationFailedException($payload, $violations));
                 }
             } else {
                 try {
-                    $payload = $this->$payloadMapper($request, $type, $attributes[0]);
+                    $payload = $this->$payloadMapper($request, $argument, $attributes[0]);
                 } catch (PartialDenormalizationException $e) {
                     throw new HttpException($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), $e->getErrors())), $e);
                 }
@@ -114,19 +114,19 @@ public function resolve(Request $request, ArgumentMetadata $argument): iterable
         return [];
     }
 
-    private function mapQueryString(Request $request, string $type, MapQueryString $attribute): ?object
+    private function mapQueryString(Request $request, ArgumentMetadata $argument, MapQueryString $attribute): ?object
     {
         if (!$data = $request->query->all()) {
             return null;
         }
 
-        return $this->serializer->denormalize($data, $type, null, self::CONTEXT_DENORMALIZE + $attribute->context);
+        return $this->serializer->denormalize($data, $argument->getType(), null, self::CONTEXT_DENORMALIZE + $attribute->context);
     }
 
-    private function mapRequestPayload(Request $request, string $type, MapRequestPayload $attribute): ?object
+    private function mapRequestPayload(Request $request, ArgumentMetadata $argument, MapRequestPayload $attribute): ?object
     {
         if ($data = $request->request->all()) {
-            return $this->serializer->denormalize($data, $type, null, self::CONTEXT_DENORMALIZE + $attribute->context);
+            return $this->serializer->denormalize($data, $argument->getType(), null, self::CONTEXT_DENORMALIZE + $attribute->context);
         }
 
         if ('' === $data = $request->getContent()) {
@@ -137,12 +137,17 @@ private function mapRequestPayload(Request $request, string $type, MapRequestPay
             throw new HttpException(Response::HTTP_UNSUPPORTED_MEDIA_TYPE, 'Unsupported format.');
         }
 
+        $acceptedFormats = is_string($attribute->format) ? [$attribute->format] : $attribute->format;
+        if (is_array($attribute->format) && !in_array($format, $acceptedFormats, true)) {
+            throw new HttpException(Response::HTTP_UNSUPPORTED_MEDIA_TYPE, sprintf('Unsupported format, expects "%s", but "%s" given.', implode('", "', $acceptedFormats), $format));
+        }
+
         if ('form' === $format) {
             throw new HttpException(Response::HTTP_BAD_REQUEST, 'Request payload contains invalid "form" data.');
         }
 
         try {
-            return $this->serializer->deserialize($data, $type, $format, self::CONTEXT_DESERIALIZE + $attribute->context);
+            return $this->serializer->deserialize($data, $argument->getType(), $format, self::CONTEXT_DESERIALIZE + $attribute->context);
         } catch (UnsupportedFormatException $e) {
             throw new HttpException(Response::HTTP_UNSUPPORTED_MEDIA_TYPE, sprintf('Unsupported format: "%s".', $format), $e);
         } catch (NotEncodableValueException $e) {
diff --git a/src/Symfony/Component/HttpKernel/Tests/Controller/ArgumentResolver/RequestPayloadValueResolverTest.php b/src/Symfony/Component/HttpKernel/Tests/Controller/ArgumentResolver/RequestPayloadValueResolverTest.php
@@ -181,6 +181,14 @@ public function testRequestInputValidationPassed()
 
         $this->assertEquals($payload, $resolver->resolve($request, $argument)[0]);
     }
+
+    public function testNonSupportedRestrictedFormatMustThrowUnsupportedMediaTypeException()
+    {
+    }
+
+    public function testRestrictGroupValidation()
+    {
+    }
 }
 
 class RequestPayload

Original file line number	Diff line number	Diff line change
`@@ -69,14 +69,14 @@ public function resolve(Request $request, ArgumentMetadata $argument): iterable`
`69`	`69`	`continue;`
`70`	`70`	`}`
`71`	`71`
`72`		`- if (!$type = $argument->getType()) {`
	`72`	`+ if (!$argument->getType()) {`
`73`	`73`	`throw new \LogicException(sprintf('Could not resolve the "$%s" controller argument: argument should be typed.', $argument->getName()));`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`if ($this->validator) {`
`77`	`77`	`$violations = new ConstraintViolationList();`
`78`	`78`	`try {`
`79`		`- $payload = $this->$payloadMapper($request, $type, $attributes[0]);`
	`79`	`+ $payload = $this->$payloadMapper($request, $argument, $attributes[0]);`
`80`	`80`	`} catch (PartialDenormalizationException $e) {`
`81`	`81`	`$trans = $this->translator ? $this->translator->trans(...) : fn ($m, $p) => strtr($m, $p);`
`82`	`82`	`foreach ($e->getErrors() as $error) {`
`@@ -92,15 +92,15 @@ public function resolve(Request $request, ArgumentMetadata $argument): iterable`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`if (null !== $payload) {`
`95`		`- $violations->addAll($this->validator->validate($payload));`
	`95`	`+ $violations->addAll($this->validator->validate($payload, null, $attributes[0]->groups ?? null));`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`if (\count($violations)) {`
`99`	`99`	`throw new HttpException($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), iterator_to_array($violations))), new ValidationFailedException($payload, $violations));`
`100`	`100`	`}`
`101`	`101`	`} else {`
`102`	`102`	`try {`
`103`		`- $payload = $this->$payloadMapper($request, $type, $attributes[0]);`
	`103`	`+ $payload = $this->$payloadMapper($request, $argument, $attributes[0]);`
`104`	`104`	`} catch (PartialDenormalizationException $e) {`
`105`	`105`	`throw new HttpException($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), $e->getErrors())), $e);`
`106`	`106`	`}`
`@@ -114,19 +114,19 @@ public function resolve(Request $request, ArgumentMetadata $argument): iterable`
`114`	`114`	`return [];`
`115`	`115`	`}`
`116`	`116`
`117`		`- private function mapQueryString(Request $request, string $type, MapQueryString $attribute): ?object`
	`117`	`+ private function mapQueryString(Request $request, ArgumentMetadata $argument, MapQueryString $attribute): ?object`
`118`	`118`	`{`
`119`	`119`	`if (!$data = $request->query->all()) {`
`120`	`120`	`return null;`
`121`	`121`	`}`
`122`	`122`
`123`		`- return $this->serializer->denormalize($data, $type, null, self::CONTEXT_DENORMALIZE + $attribute->context);`
	`123`	`+ return $this->serializer->denormalize($data, $argument->getType(), null, self::CONTEXT_DENORMALIZE + $attribute->context);`
`124`	`124`	`}`
`125`	`125`
`126`		`- private function mapRequestPayload(Request $request, string $type, MapRequestPayload $attribute): ?object`
	`126`	`+ private function mapRequestPayload(Request $request, ArgumentMetadata $argument, MapRequestPayload $attribute): ?object`
`127`	`127`	`{`
`128`	`128`	`if ($data = $request->request->all()) {`
`129`		`- return $this->serializer->denormalize($data, $type, null, self::CONTEXT_DENORMALIZE + $attribute->context);`
	`129`	`+ return $this->serializer->denormalize($data, $argument->getType(), null, self::CONTEXT_DENORMALIZE + $attribute->context);`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`if ('' === $data = $request->getContent()) {`
`@@ -137,12 +137,17 @@ private function mapRequestPayload(Request $request, string $type, MapRequestPay`
`137`	`137`	`throw new HttpException(Response::HTTP_UNSUPPORTED_MEDIA_TYPE, 'Unsupported format.');`
`138`	`138`	`}`
`139`	`139`
	`140`	`+ $acceptedFormats = is_string($attribute->format) ? [$attribute->format] : $attribute->format;`
	`141`	`+ if (is_array($attribute->format) && !in_array($format, $acceptedFormats, true)) {`
	`142`	`+ throw new HttpException(Response::HTTP_UNSUPPORTED_MEDIA_TYPE, sprintf('Unsupported format, expects "%s", but "%s" given.', implode('", "', $acceptedFormats), $format));`
	`143`	`+ }`
	`144`	`+`
`140`	`145`	`if ('form' === $format) {`
`141`	`146`	`throw new HttpException(Response::HTTP_BAD_REQUEST, 'Request payload contains invalid "form" data.');`
`142`	`147`	`}`
`143`	`148`
`144`	`149`	`try {`
`145`		`- return $this->serializer->deserialize($data, $type, $format, self::CONTEXT_DESERIALIZE + $attribute->context);`
	`150`	`+ return $this->serializer->deserialize($data, $argument->getType(), $format, self::CONTEXT_DESERIALIZE + $attribute->context);`
`146`	`151`	`} catch (UnsupportedFormatException $e) {`
`147`	`152`	`throw new HttpException(Response::HTTP_UNSUPPORTED_MEDIA_TYPE, sprintf('Unsupported format: "%s".', $format), $e);`
`148`	`153`	`} catch (NotEncodableValueException $e) {`
Original file line number	Diff line number	Diff line change
`@@ -181,6 +181,14 @@ public function testRequestInputValidationPassed()`
`181`	`181`
`182`	`182`	`$this->assertEquals($payload, $resolver->resolve($request, $argument)[0]);`
`183`	`183`	`}`
	`184`	`+`
	`185`	`+ public function testNonSupportedRestrictedFormatMustThrowUnsupportedMediaTypeException()`
	`186`	`+ {`
	`187`	`+ }`
	`188`	`+`
	`189`	`+ public function testRestrictGroupValidation()`
	`190`	`+ {`
	`191`	`+ }`
`184`	`192`	`}`
`185`	`193`
`186`	`194`	`class RequestPayload`