[Serializer] Redesign component

Author: mtarld

src/Symfony/Bundle/FrameworkBundle/CHANGELOG.md

@@ -4,6 +4,7 @@ CHANGELOG
 7.0
 ---
 
+ * Add support for the experimental revamped version of the Serializer component
  * Remove command `translation:update`, use `translation:extract` instead
  * Make the `http_method_override` config option default to `false`
  * Remove `AbstractController::renderForm()`, use `render()` instead

src/Symfony/Bundle/FrameworkBundle/CacheWarmer/SerializerLazyGhostCacheWarmer.php

@@ -0,0 +1,74 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\FrameworkBundle\CacheWarmer;
+
+use Symfony\Component\HttpKernel\CacheWarmer\CacheWarmer;
+use Symfony\Component\Serializer\Type\Type;
+use Symfony\Component\VarExporter\ProxyHelper;
+
+/**
+ * Generates lazy ghost {@see Symfony\Component\VarExporter\LazyGhostTrait}
+ * PHP files for $serializable types.
+ *
+ * @author Mathias Arlaud <[email protected]>
+ *
+ * @experimental in 7.0
+ */
+final class SerializerLazyGhostCacheWarmer extends CacheWarmer
+{
+    /**
+     * @param list<string> $serializable
+     */
+    public function __construct(
+        private readonly array $serializable,
+        private readonly string $lazyGhostCacheDir,
+    ) {
+    }
+
+    public function warmUp(string $cacheDir): array
+    {
+        if (!file_exists($this->lazyGhostCacheDir)) {
+            mkdir($this->lazyGhostCacheDir, recursive: true);
+        }
+
+        foreach ($this->serializable as $s) {
+            $type = Type::fromString($s);
+
+            if (!$type->isObject() || !$type->hasClass()) {
+                continue;
+            }
+
+            $this->warmClassLazyGhost($type->className());
+        }
+
+        return [];
+    }
+
+    public function isOptional(): bool
+    {
+        return false;
+    }
+
+    /**
+     * @param class-string $className
+     */
+    private function warmClassLazyGhost(string $className): void
+    {
+        $path = sprintf('%s%s%s.php', $this->lazyGhostCacheDir, \DIRECTORY_SEPARATOR, hash('xxh128', $className));
+
+        $this->writeCacheFile($path, sprintf(
+            'class %s%s',
+            sprintf('%sGhost', preg_replace('/\\\\/', '', $className)),
+            ProxyHelper::generateLazyGhost(new \ReflectionClass($className)),
+        ));
+    }
+}

src/Symfony/Bundle/FrameworkBundle/CacheWarmer/SerializerTemplateCacheWarmer.php

@@ -0,0 +1,139 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\FrameworkBundle\CacheWarmer;
+
+use Psr\Log\LoggerInterface;
+use Psr\Log\NullLogger;
+use Symfony\Component\HttpKernel\CacheWarmer\CacheWarmer;
+use Symfony\Component\Serializer\Deserialize\Config\DeserializeConfig;
+use Symfony\Component\Serializer\Deserialize\Template\Template as DeserializeTemplate;
+use Symfony\Component\Serializer\Exception\ExceptionInterface;
+use Symfony\Component\Serializer\Serialize\Config\SerializeConfig;
+use Symfony\Component\Serializer\Serialize\Template\Template as SerializeTemplate;
+use Symfony\Component\Serializer\Template\TemplateVariant;
+use Symfony\Component\Serializer\Template\TemplateVariation;
+use Symfony\Component\Serializer\Template\TemplateVariationExtractorInterface;
+use Symfony\Component\Serializer\Type\Type;
+
+/**
+ * Generates serialization and deserialization templates PHP files.
+ *
+ * It generates templates for each $formats and each variants
+ * of $serializable types limited to $maxVariants.
+ *
+ * @author Mathias Arlaud <[email protected]>
+ *
+ * @experimental in 7.0
+ */
+final class SerializerTemplateCacheWarmer extends CacheWarmer
+{
+    /**
+     * @param list<string> $serializable
+     * @param list<string> $formats
+     */
+    public function __construct(
+        private readonly array $serializable,
+        private readonly SerializeTemplate $serializeTemplate,
+        private readonly DeserializeTemplate $deserializeTemplate,
+        private readonly TemplateVariationExtractorInterface $templateVariationExtractor,
+        private readonly string $templateCacheDir,
+        private readonly array $formats,
+        private readonly int $maxVariants,
+        private readonly LoggerInterface $logger = new NullLogger(),
+    ) {
+    }
+
+    public function warmUp(string $cacheDir): array
+    {
+        if (!file_exists($this->templateCacheDir)) {
+            mkdir($this->templateCacheDir, recursive: true);
+        }
+
+        foreach ($this->serializable as $s) {
+            $type = Type::fromString($s);
+
+            $variations = $this->templateVariationExtractor->extractVariationsFromType($type);
+            $variants = $this->variants($variations);
+
+            if (\count($variants) > $this->maxVariants) {
+                $this->logger->debug('Too many variants for "{type}", keeping only the first {maxVariants}.', ['type' => $s, 'maxVariants' => $this->maxVariants]);
+                $variants = \array_slice($variants, offset: 0, length: $this->maxVariants);
+            }
+
+            foreach ($this->formats as $format) {
+                $this->warmTemplates($type, $variants, $format);
+            }
+        }
+
+        return [];
+    }
+
+    public function isOptional(): bool
+    {
+        return false;
+    }
+
+    /**
+     * @param list<array{serialize: TemplateVariant, deserialize: TemplateVariant}> $variants
+     */
+    private function warmTemplates(Type $type, array $variants, string $format): void
+    {
+        foreach ($variants as $variant) {
+            try {
+                $this->writeCacheFile(
+                    $this->serializeTemplate->path($type, $format, $variant['serialize']->config),
+                    $this->serializeTemplate->content($type, $format, $variant['serialize']->config),
+                );
+            } catch (ExceptionInterface $e) {
+                $this->logger->debug('Cannot generate serialize "{format}" template for "{type}": {exception}', [
+                    'format' => $format,
+                    'type' => (string) $type,
+                    'exception' => $e,
+                ]);
+            }
+
+            try {
+                $this->writeCacheFile(
+                    $this->deserializeTemplate->path($type, $format, $variant['deserialize']->config),
+                    $this->deserializeTemplate->content($type, $format, $variant['deserialize']->config),
+                );
+            } catch (ExceptionInterface $e) {
+                $this->logger->debug('Cannot generate deserialize "{format}" template for "{type}": {exception}', [
+                    'format' => $format,
+                    'type' => (string) $type,
+                    'exception' => $e,
+                ]);
+            }
+        }
+    }
+
+    /**
+     * @param list<TemplateVariation> $variations
+     *
+     * @return list<array{serialize: TemplateVariant, deserialize: TemplateVariant}>
+     */
+    private function variants(array $variations): array
+    {
+        $variants = [[]];
+
+        foreach ($variations as $variation) {
+            foreach ($variants as $variant) {
+                $variants[] = array_merge([$variation], $variant);
+            }
+        }
+
+        return array_map(fn (array $variations): array => [
+            'serialize' => new TemplateVariant(new SerializeConfig(), $variations),
+            'deserialize' => new TemplateVariant(new DeserializeConfig(), $variations),
+        ], $variants);
+    }
+}

src/Symfony/Bundle/FrameworkBundle/DependencyInjection/Compiler/UnusedTagsPass.php

@@ -86,8 +86,11 @@ class UnusedTagsPass implements CompilerPassInterface
         'security.expression_language_provider',
         'security.remember_me_handler',
         'security.voter',
+        'serializer.deserialize.template_generator.eager',
+        'serializer.deserialize.template_generator.lazy',
         'serializer.encoder',
         'serializer.normalizer',
+        'serializer.serialize.template_generator',
         'texter.transport_factory',
         'translation.dumper',
         'translation.extractor',

src/Symfony/Bundle/FrameworkBundle/DependencyInjection/Configuration.php

@@ -1091,6 +1091,8 @@ private function addSerializerSection(ArrayNodeDefinition $rootNode, callable $e
                 ->arrayNode('serializer')
                     ->info('serializer configuration')
                     ->{$enableIfStandalone('symfony/serializer', Serializer::class)}()
+                    ->fixXmlConfig('serializable_path')
+                    ->fixXmlConfig('format')
                     ->children()
                         ->booleanNode('enable_attributes')->{!class_exists(FullStack::class) ? 'defaultTrue' : 'defaultFalse'}()->end()
                         ->scalarNode('name_converter')->end()
@@ -1115,6 +1117,31 @@ private function addSerializerSection(ArrayNodeDefinition $rootNode, callable $e
                             ->defaultValue([])
                             ->prototype('variable')->end()
                         ->end()
+                        ->arrayNode('serializable_paths')
+                            ->info('Defines where to find classes to serialized/deserialized.')
+                            ->beforeNormalization()->ifString()->then(function ($v) { return [$v]; })->end()
+                            ->prototype('scalar')->end()
+                            ->defaultValue([])
+                        ->end()
+                        ->arrayNode('formats')
+                            ->info('Defines formats to generate template during cache warm up.')
+                            ->beforeNormalization()->ifString()->then(function ($v) { return [$v]; })->end()
+                            ->prototype('scalar')->end()
+                            ->defaultValue(['json'])
+                        ->end()
+                        ->integerNode('max_variants')
+                            ->info('Defines the maximum template variants allowed for each class during cache warm up.')
+                            ->defaultValue(32)
+                            ->min(0)
+                        ->end()
+                        ->booleanNode('lazy_deserialization')
+                            ->info('Defines whether to read data lazily or eagerly.')
+                            ->defaultFalse()
+                        ->end()
+                        ->booleanNode('lazy_instantiation')
+                            ->info('Defines whether to instantiate objects lazily or eagerly.')
+                            ->defaultFalse()
+                        ->end()
                     ->end()
                 ->end()
             ->end()

src/Symfony/Bundle/FrameworkBundle/DependencyInjection/FrameworkExtension.php

@@ -14,6 +14,10 @@
 use Composer\InstalledVersions;
 use Http\Client\HttpAsyncClient;
 use Http\Client\HttpClient;
+use Symfony\Component\Serializer\Deserialize\Instantiator\InstantiatorInterface;
+use Symfony\Component\Serializer\Serialize\SerializerInterface as ExperimentalSerializerInterface;
+use Symfony\Component\Serializer\Type\PhpstanTypeExtractor;
+use Symfony\Component\Serializer\Type\TypeExtractorInterface;
 use phpDocumentor\Reflection\DocBlockFactoryInterface;
 use phpDocumentor\Reflection\Types\ContextFactory;
 use PhpParser\Parser;
@@ -372,6 +376,10 @@ public function load(array $configs, ContainerBuilder $container): void
             }
 
             $this->registerSerializerConfiguration($config['serializer'], $container, $loader);
+
+            if (interface_exists(ExperimentalSerializerInterface::class)) {
+                $this->registerExperimentalSerializerConfiguration($config['serializer'], $container, $loader);
+            }
         } else {
             $container->getDefinition('argument_resolver.request_payload')
                 ->setArguments([])
@@ -1889,6 +1897,42 @@ private function registerSerializerConfiguration(array $config, ContainerBuilder
         }
     }
 
+    private function registerExperimentalSerializerConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
+    {
+        $loader->load('serializer_experimental.php');
+
+        $container->setParameter('serializer.serializable_paths', $config['serializable_paths']);
+        $container->setParameter('serializer.formats', $config['formats']);
+        $container->setParameter('serializer.max_variants', $config['max_variants']);
+
+        $container->setParameter('serializer.lazy_instantiation', $config['lazy_instantiation']);
+        $container->setParameter('serializer.lazy_deserialization', $config['lazy_deserialization']);
+
+        $container->setAlias('serializer.instantiator', $config['lazy_instantiation'] ? 'serializer.instantiator.lazy' : 'serializer.instantiator.eager');
+        $container->setAlias(InstantiatorInterface::class, 'serializer.instantiator');
+
+        foreach ($config['serializable_paths'] as $path) {
+            if (!is_dir($path)) {
+                continue;
+            }
+
+            $container->fileExists($path, '/\.php$/');
+        }
+
+        if (
+            ContainerBuilder::willBeAvailable('phpstan/phpdoc-parser', PhpDocParser::class, ['symfony/framework-bundle', 'symfony/serializer'])
+            && ContainerBuilder::willBeAvailable('phpdocumentor/type-resolver', ContextFactory::class, ['symfony/framework-bundle', 'symfony/serializer'])
+        ) {
+            $container->register('serializer.type_extractor.phpstan', PhpstanTypeExtractor::class)
+                ->setDecoratedService('serializer.type_extractor')
+                ->setArguments([
+                    new Reference('serializer.type_extractor.phpstan.inner'),
+                ])
+                ->setLazy(true)
+                ->addTag('proxy', ['interface' => TypeExtractorInterface::class]);
+        }
+    }
+
     private function registerPropertyInfoConfiguration(ContainerBuilder $container, PhpFileLoader $loader): void
     {
         if (!interface_exists(PropertyInfoExtractorInterface::class)) {

src/Symfony/Bundle/FrameworkBundle/FrameworkBundle.php

@@ -59,6 +59,8 @@
 use Symfony\Component\PropertyInfo\DependencyInjection\PropertyInfoPass;
 use Symfony\Component\Routing\DependencyInjection\RoutingResolverPass;
 use Symfony\Component\Scheduler\DependencyInjection\AddScheduleMessengerPass;
+use Symfony\Component\Serializer\DependencyInjection\RuntimeSerializerServicesPass;
+use Symfony\Component\Serializer\DependencyInjection\SerializablePass;
 use Symfony\Component\Serializer\DependencyInjection\SerializerPass;
 use Symfony\Component\Translation\DependencyInjection\TranslationDumperPass;
 use Symfony\Component\Translation\DependencyInjection\TranslationExtractorPass;
@@ -152,6 +154,9 @@ public function build(ContainerBuilder $container): void
         $this->addCompilerPassIfExists($container, TranslationExtractorPass::class);
         $this->addCompilerPassIfExists($container, TranslationDumperPass::class);
         $container->addCompilerPass(new FragmentRendererPass());
+        // must be registered before the SerializerPass and RuntimeSerializerServicesPass
+        $this->addCompilerPassIfExists($container, SerializablePass::class, priority: 16);
+        $this->addCompilerPassIfExists($container, RuntimeSerializerServicesPass::class);
         $this->addCompilerPassIfExists($container, SerializerPass::class);
         $this->addCompilerPassIfExists($container, PropertyInfoPass::class);
         $container->addCompilerPass(new ControllerArgumentValueResolverPass());