[Serializer] Fixed BackedEnumNormalizer priority for translatable enum

[IndraGunawan]

Q	A
Branch?	6.4
Bug fix?	yes
New feature?	no
Deprecations?	no
Issues
License	MIT

enum MyEnum: string implements TranslatableInterface
{
    case Get = 'GET';
    case Post = 'POST';
    case Update = 'UPDATE';

    public function trans(TranslatorInterface $translator, ?string $locale = null): string
    {
        return match ($this) {
            self::Get  => 'custom_get',
            self::Post  => 'custom_post',
            self::Update => 'custom_update'
        };
    }
}

class MyController {
    public function __invoke(SerializerInterface $serializer) {
        dd($serializer->serialize(MyEnum::Get)); // ""custom_get"" , Expected result: ""GET""
    }
}

serialize a BackedEnum that implements TranslatableInterface will return the translation value instead of the enum item value. this is because TranslatableNormalizer (ref) has higher priority than BackedEnumNormalizer

this PR changes the BackedEnumNormalizer priority higher than TranslatableNormalizer priority

[chalasr]

Good catch, thanks @IndraGunawan.

[xabbuh]

What if someone relies on the current order? Do we consider this an unsupported use case?

[chalasr]

Good question. I would say yes as there are similar precedents changing e.g. compiler passes order or event listeners priority as part of a bugfix. It's probably worth being decided on a case-by-case basis and mentioned in the BC promise.

[ambroisemaupate]

This change breaks the way ApiPlatform exposes BackEnum as ApiResource

api-platform/core/issues/6279

[Valentin-CosaVostra]

As a BC break workaround, the easiest and maintainable way I found is to create a custom normalizer.

For example, the project I'm working on needed the translated enumerations on serialization:

use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Contracts\Translation\TranslatableInterface;
use Symfony\Contracts\Translation\TranslatorInterface;

final readonly class AcmeNormalizer implements NormalizerInterface
{
    public function __construct(private TranslatorInterface $translator)
    {
    }

    /**
     * @param TranslatableInterface $object
     */
    public function normalize($object, ?string $format = null, array $context = []): string
    {
        return $object->trans($this->translator);
    }

    public function supportsNormalization($data, ?string $format = null, array $context = []): bool
    {
        return $data instanceof TranslatableInterface;
    }

    public function getSupportedTypes(?string $format): array
    {
        return [
            TranslatableInterface::class => true,
        ];
    }
}

I don't know if this is the best way to do it or not but it seems to me to be quite maintainable.

[chalasr]

Implementation changed in #54484