api: set rfc_7807_compliant_errors to true

It was a little tricky, but finally i figured out how to do it:
https://api-platform.com/docs/core/errors/

The big impact is, that the serialization of the errors is now
done with the same infrastructure as serializing entities.
That makes it less format dependent.

It seems a little weird that we use a provider to "replace" the exception path
of the response by extracting the exception to the context,
and then continuing like when we would serialize a response.
But i can also see the benefits.
See api-platform/core#5974

Issue: ecamp#6618

Author: BacLuc

api/config/packages/api_platform.yaml

@@ -30,7 +30,7 @@ api_platform:
         stateless: true
         extra_properties:
             standard_put: true
-            rfc_7807_compliant_errors: false
+            rfc_7807_compliant_errors: true
         pagination_enabled: false
         itemOperations: [ 'get', 'patch', 'delete' ]
         collection_operations:

api/config/services.yaml

@@ -73,10 +73,13 @@ services:
     App\Serializer\Normalizer\CollectionItemsNormalizer:
         decorates: 'api_platform.hal.normalizer.collection'
 
-    App\Serializer\Normalizer\TranslationConstraintViolationListNormalizer:
+    App\State\ValidationErrorProvider:
+        decorates: 'api_platform.validator.state.error_provider'
         arguments:
-            - '@api_platform.hydra.normalizer.constraint_violation_list'
-            - '@api_platform.problem.normalizer.constraint_violation_list'
+            - '@.inner'
+            - '@serializer.normalizer.error.translation_info_of_constraint_violation'
+            - '@service.translation_to_all_locales'
+            - '@serializer.name_converter.metadata_aware'
 
     App\Serializer\SerializerContextBuilder:
         decorates: 'api_platform.serializer.context_builder'
@@ -137,13 +140,17 @@ services:
             - "%env(MAIL_FROM_EMAIL)%"
             - "%env(MAIL_FROM_NAME)%"
 
-    App\Service\TranslateToAllLocalesService:
+    service.translation_to_all_locales:
+        class: App\Service\TranslateToAllLocalesService
         public: true
         arguments:
             - '@translator'
             - '@translator'
             - '%env(csv:TRANSLATE_ERRORS_TO_LOCALES)%'
 
+    serializer.normalizer.error.translation_info_of_constraint_violation:
+        class: App\Serializer\Normalizer\Error\TranslationInfoOfConstraintViolation
+
     App\EventListener\JWTCreatedListener:
         tags:
             - { name: kernel.event_listener, event: lexik_jwt_authentication.on_jwt_created, method: onJWTCreated }

api/src/DTO/ValidationError.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\DTO;
+
+use ApiPlatform\ApiResource\Error;
+use ApiPlatform\Metadata\ApiProperty;
+
+class ValidationError extends Error {
+    public function __construct(
+        private readonly ?string $title,
+        private readonly int $status,
+        private readonly ?string $detail,
+        private readonly ?string $instance,
+        private readonly array $violations = [],
+        private readonly string $type = 'about:blank',
+    ) {
+        parent::__construct(
+            type: $this->type,
+            title: $this->title,
+            status: $this->status,
+            detail: $this->detail,
+            instance: $this->instance,
+        );
+    }
+
+    #[ApiProperty]
+    public function getViolations(): array {
+        return $this->violations;
+    }
+}

api/src/Serializer/Normalizer/Error/TranslationInfoOfConstraintViolation.php

@@ -2,10 +2,10 @@
 
 namespace App\Serializer\Normalizer\Error;
 
-use Symfony\Component\Validator\ConstraintViolation;
+use Symfony\Component\Validator\ConstraintViolationInterface;
 
 class TranslationInfoOfConstraintViolation {
-    public function extract(ConstraintViolation $constraintViolation): TranslationInfo {
+    public function extract(ConstraintViolationInterface $constraintViolation): TranslationInfo {
         $constraint = $constraintViolation->getConstraint();
         $constraintClass = get_class($constraint);
         $key = str_replace('\\', '.', $constraintClass);

api/src/Serializer/Normalizer/TranslationConstraintViolationListNormalizer.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Serializer\Normalizer;
+
+use App\DTO\ValidationError;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+class ValidationErrorNormalizer implements NormalizerInterface {
+    public const TYPE = 'type';
+    public const TITLE = 'title';
+    private array $defaultContext = [
+        self::TYPE => 'https://tools.ietf.org/html/rfc2616#section-10',
+        self::TITLE => 'An error occurred',
+    ];
+
+    public function normalize(mixed $data, ?string $format = null, array $context = []): null|array|\ArrayObject|bool|float|int|string {
+        return [
+            'type' => $context[self::TYPE] ?? $this->defaultContext[self::TYPE],
+            'title' => $context[self::TITLE] ?? $this->defaultContext[self::TITLE],
+            'detail' => $data->getDetail(),
+            'violations' => $data->getViolations(),
+        ];
+    }
+
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool {
+        return $data instanceof ValidationError;
+    }
+
+    public function getSupportedTypes(?string $format): array {
+        return [ValidationError::class => true];
+    }
+}

api/src/Serializer/Normalizer/ValidationErrorNormalizer.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace App\State;
+
+use ApiPlatform\Metadata\HttpOperation;
+use ApiPlatform\Metadata\Operation;
+use ApiPlatform\State\ApiResource\Error;
+use ApiPlatform\State\ProviderInterface;
+use ApiPlatform\Validator\Exception\ValidationException;
+use App\DTO\ValidationError;
+use App\Serializer\Normalizer\Error\TranslationInfoOfConstraintViolation;
+use App\Service\TranslateToAllLocalesService;
+use Symfony\Component\Serializer\NameConverter\MetadataAwareNameConverter;
+
+/**
+ * @psalm-suppress MissingTemplateParam
+ */
+class ValidationErrorProvider implements ProviderInterface {
+    public function __construct(
+        private readonly ProviderInterface $decorated,
+        private readonly TranslationInfoOfConstraintViolation $translationInfoOfConstraintViolation,
+        private readonly TranslateToAllLocalesService $translateToAllLocalesService,
+        private readonly MetadataAwareNameConverter $nameConverter
+    ) {}
+
+    /**
+     * @psalm-suppress InvalidReturnStatement
+     */
+    public function provide(Operation $operation, array $uriVariables = [], array $context = []): null|array|object {
+        $request = $context['request'];
+        $exception = $request?->attributes->get('exception');
+        if (!($request ?? null) || !$operation instanceof HttpOperation || null === $exception) {
+            throw new \RuntimeException('Not an HTTP request');
+        }
+
+        $status = $operation->getStatus() ?? 500;
+        $error = Error::createFromException($exception, $status);
+        if (!$exception instanceof ValidationException) {
+            return $this->decorated->provide($operation, $uriVariables, $context);
+        }
+
+        /**
+         * @var ValidationException $exception
+         */
+        $violationInfos = [];
+        foreach ($exception->getConstraintViolationList() as $violation) {
+            $violationInfo = $this->translationInfoOfConstraintViolation->extract($violation);
+            $translations = $this->translateToAllLocalesService->translate(
+                $violation->getMessageTemplate(),
+                array_merge(
+                    $violation->getPlural() ? ['%count%' => $violation->getPlural()] : [],
+                    $violation->getParameters()
+                )
+            );
+
+            $propertyPath = $this->nameConverter->normalize($violation->getPropertyPath(), $violation->getRoot()::class, 'jsonproblem');
+
+            $violationInfos[] = [
+                'code' => $violation->getCode(),
+                'propertyPath' => $propertyPath,
+                'message' => $violation->getMessage(),
+                'i18n' => [
+                    ...(array) $violationInfo,
+                    'translations' => $translations,
+                ],
+            ];
+        }
+
+        return new ValidationError(
+            type: $error->getType(),
+            title: $error->getTitle(),
+            status: $status,
+            detail: $error->getDetail(),
+            instance: $error->getInstance(),
+            violations: $violationInfos
+        );
+    }
+}