Add CacheableNormalization for Normalizer to return Normalized value and Cacheablity

As much as I'd like to see this happen, I'm not very optimistic about the BC aspects of this. In either solution you propose, we need pretty much every normalizer in core and contrib to implement that fallback logic. 😔

And perhaps even more importantly: it violates \Symfony\Component\Serializer\Normalizer\NormalizerInterface::normalize().

The solution I explored for this in the JSON:API issue was to not have every normalizer be able to return a CacheableNormalization, but instead allow the serializer "upcast" raw normalizations. Then, various normalizers could start to 'opt-in' and the serializer could skip the wrapping step.

I'm sure there are problems to solve there, but it might get something rolling.

We talked about this yesterday during the API-First meeting. @gabesullice explained his idea in more detail: where essentially the serializer service inspects each normalizer service's service tags, and if they indicate that they're returning CacheableNormalization objects, the serializer service will handle any transformations necessary to let different normalizers collaborate like they do today.

@jibran, is that sufficient, or would you like us to explain this in more detail?

Thinking about it more, I don't think any interfaces or service tags are actually necessary. I think it could work a bit like this:

class Serializer {

  public function normalize($object, $format, $context) {
    $return_as_object = isset($context['return_as_object']) && $context['return_as_object'];
    // Ensure that the 'return_as_object' flag does not get passed down through
    // recursive calls from normalizers which cannot handle
    // CacheableNormalization objects.
    unset($context['return_as_object']);
    $normalizer = $this->getNormalizer($object, $format, $context);
    $normalization = $normalizer->normalize($object, $format, $context);
    $has_serialization_context = isset($context[CacheableNormalizerInterface::SERIALIZATION_CONTEXT_CACHEABILITY]);
    if ($normalization instanceof CacheableNormalization) {
      if ($return_as_object) {
        return $normalization;
      }
      else {
        if ($has_serialization_context) {
          $context[CacheableNormalizerInterface::SERIALIZATION_CONTEXT_CACHEABILITY]->addCacheableDependency($normalization);
        }
        else {
          $context[CacheableNormalizerInterface::SERIALIZATION_CONTEXT_CACHEABILITY] = CacheableMetadata::createFromObject($normalization);
        }
        return $normalization->getNormalization();
      }
    }
    else {
      // deprecation notice to start requiring CacheableNormalizations.
      if ($return_as_object) {
        if ($has_serialization_context) {
          return new CacheableNormalization($context[CacheableNormalizerInterface::SERIALIZATION_CONTEXT_CACHEABILITY], $normalization);
        }
        else {
          return new CacheableNormalization(new CacheableMetadata(), $normalization);
        }
      }
      else {
        return $normalization;
      }
    }
  }

}

+1