[SerDes] Introduce component

composer.json

@@ -84,6 +84,7 @@
         "symfony/ldap": "self.version",
         "symfony/lock": "self.version",
         "symfony/mailer": "self.version",
+        "symfony/ser-des": "self.version",
         "symfony/messenger": "self.version",
         "symfony/mime": "self.version",
         "symfony/monolog-bridge": "self.version",
@@ -186,7 +187,8 @@
             "Symfony\\Component\\": "src/Symfony/Component/"
         },
         "files": [
-            "src/Symfony/Component/String/Resources/functions.php"
+            "src/Symfony/Component/String/Resources/functions.php",
+            "src/Symfony/Component/SerDes/Resources/functions.php"
         ],
         "classmap": [
             "src/Symfony/Component/Cache/Traits/ValueWrapper.php"

src/Symfony/Bundle/FrameworkBundle/CHANGELOG.md

@@ -1,6 +1,11 @@
 CHANGELOG
 =========
 
+7.0
+---
+
+ * Register SerDes services
+
 6.3
 ---
 

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

@@ -0,0 +1,147 @@
+<?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\SerDes\Context\ContextBuilder\ContextBuilderInterface;
+use Symfony\Component\SerDes\Context\ContextBuilder\SerializeContextBuilderInterface;
+use Symfony\Component\SerDes\Exception\ExceptionInterface;
+use Symfony\Component\SerDes\SerializableResolver\SerializableResolverInterface;
+use Symfony\Component\SerDes\Template\TemplateHelper;
+use Symfony\Component\SerDes\Template\TemplateVariation;
+use Symfony\Component\VarExporter\ProxyHelper;
+
+use function Symfony\Component\SerDes\serialize_generate;
+
+/**
+ * @author Mathias Arlaud <[email protected]>
+ *
+ * @experimental in 7.0
+ */
+final class SerDesCacheWarmer extends CacheWarmer
+{
+    /**
+     * @var iterable<ContextBuilderInterface>
+     */
+    private iterable $contextBuilders = [];
+
+    private readonly TemplateHelper $templateHelper;
+
+    /**
+     * @param iterable<SerializeContextBuilderInterface> $contextBuilders
+     * @param list<string>                               $formats
+     */
+    public function __construct(
+        private readonly SerializableResolverInterface $serializableResolver,
+        private readonly string $templateCacheDir,
+        private readonly string $lazyObjectCacheDir,
+        private readonly array $formats,
+        private readonly int $maxVariants,
+        private readonly LoggerInterface $logger = new NullLogger(),
+    ) {
+        $this->templateHelper = new TemplateHelper($this->templateCacheDir);
+    }
+
+    public function warmUp(string $cacheDir): array
+    {
+        if (!file_exists($this->templateCacheDir)) {
+            mkdir($this->templateCacheDir, recursive: true);
+        }
+
+        if (!file_exists($this->lazyObjectCacheDir)) {
+            mkdir($this->lazyObjectCacheDir, recursive: true);
+        }
+
+        foreach ($this->serializableResolver->resolve() as $className) {
+            $variants = $this->templateHelper->classTemplateVariants($className);
+            if (\count($variants) > $this->maxVariants) {
+                $this->logger->debug('Too many variants for "{className}", keeping only the first {maxVariants}.', ['className' => $className, 'maxVariants' => $this->maxVariants]);
+                $variants = array_slice($variants, offset: 0, length: $this->maxVariants);
+            }
+
+            foreach ($this->formats as $format) {
+                $this->warmClassTemplate($className, $variants, $format);
+            }
+
+            $this->warmClassLazyObject($className);
+        }
+
+        return [];
+    }
+
+    public function isOptional(): bool
+    {
+        return false;
+    }
+
+    /**
+     * @param iterable<ContextBuilderInterface> $contextBuilders
+     *
+     * @internal
+     */
+    public function setContextBuilders(iterable $contextBuilders): void
+    {
+        $this->contextBuilders = $contextBuilders;
+    }
+
+    /**
+     * @param class-string $className
+     * @param list<list<TemplateVariation>> $variants
+     */
+    private function warmClassTemplate(string $className, array $variants, string $format): void
+    {
+        try {
+            $context = [
+                'cache_dir' => $this->templateCacheDir,
+                'template_exists' => false,
+            ];
+
+            foreach ($this->contextBuilders as $contextBuilder) {
+                $context = $contextBuilder->build($context, true);
+            }
+
+            foreach ($variants as $variant) {
+                $variantContext = $context;
+
+                $groupVariations = array_filter($variant, fn (TemplateVariation $v): bool => 'group' === $v->type);
+                if ([] !== $groupVariations) {
+                    $variantContext['groups'] = array_map(fn (TemplateVariation $v): string => $v->value, $groupVariations);
+                }
+
+                $variantFilename = $this->templateHelper->templateFilename($className, $format, $variantContext);
+
+                $this->writeCacheFile(
+                    $this->templateCacheDir.\DIRECTORY_SEPARATOR.$variantFilename,
+                    serialize_generate($className, $format, $variantContext),
+                );
+            }
+        } catch (ExceptionInterface $e) {
+            $this->logger->debug('Cannot generate template for "{className}": {exception}', ['className' => $className, 'exception' => $e]);
+        }
+    }
+
+    /**
+     * @param class-string $className
+     */
+    private function warmClassLazyObject(string $className): void
+    {
+        $path = sprintf('%s%s%s.php', $this->lazyObjectCacheDir, \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/DependencyInjection/Configuration.php

@@ -33,6 +33,7 @@
 use Symfony\Component\Lock\Lock;
 use Symfony\Component\Lock\Store\SemaphoreStore;
 use Symfony\Component\Mailer\Mailer;
+use Symfony\Component\SerDes\Serializer as SerDesSerializer;
 use Symfony\Component\Messenger\MessageBusInterface;
 use Symfony\Component\Notifier\Notifier;
 use Symfony\Component\PropertyAccess\PropertyAccessor;
@@ -188,6 +189,7 @@ public function getConfigTreeBuilder(): TreeBuilder
         $this->addHtmlSanitizerSection($rootNode, $enableIfStandalone);
         $this->addWebhookSection($rootNode, $enableIfStandalone);
         $this->addRemoteEventSection($rootNode, $enableIfStandalone);
+        $this->addSerDesSection($rootNode, $enableIfStandalone);
 
         return $treeBuilder;
     }
@@ -2492,4 +2494,42 @@ private function addHtmlSanitizerSection(ArrayNodeDefinition $rootNode, callable
             ->end()
         ;
     }
+
+    private function addSerDesSection(ArrayNodeDefinition $rootNode, callable $enableIfStandalone): void
+    {
+        $rootNode
+            ->children()
+                ->arrayNode('ser_des')
+                    ->info('SerDes configuration')
+                    ->{$enableIfStandalone('symfony/ser-des', SerDesSerializer::class)}()
+                    ->fixXmlConfig('serializable_path')
+                    ->children()
+                        ->arrayNode('serializable_paths')
+                            ->info('Defines where to find serializable classes.')
+                            ->beforeNormalization()->ifString()->then(function ($v) { return [$v]; })->end()
+                            ->prototype('scalar')->end()
+                            ->defaultValue([])
+                        ->end()
+                        ->arrayNode('template_warm_up')
+                            ->addDefaultsIfNotSet()
+                            ->fixXmlConfig('format')
+                            ->children()
+                                ->arrayNode('formats')
+                                    ->info('Defines the formats that will be handled.')
+                                    ->beforeNormalization()->ifString()->then(function ($v) { return [$v]; })->end()
+                                    ->prototype('scalar')->end()
+                                    ->defaultValue(['json'])
+                                ->end()
+                                ->integerNode('max_variants')
+                                    ->info('Defines the maximum variants allowed for each class.')
+                                    ->defaultValue(32)
+                                    ->min(0)
+                                ->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                ->end()
+            ->end()
+        ;
+    }
 }

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

@@ -15,6 +15,10 @@
 use Doctrine\Common\Annotations\Reader;
 use Http\Client\HttpAsyncClient;
 use Http\Client\HttpClient;
+use Symfony\Component\SerDes\Context\ContextBuilderInterface;
+use Symfony\Component\SerDes\Context\ContextBuilder\DeserializeContextBuilderInterface;
+use Symfony\Component\SerDes\Context\ContextBuilder\SerializeContextBuilderInterface;
+use Symfony\Component\SerDes\SerializerInterface as SerDesSerializerInterface;
 use phpDocumentor\Reflection\DocBlockFactoryInterface;
 use phpDocumentor\Reflection\Types\ContextFactory;
 use PhpParser\Parser;
@@ -568,6 +572,10 @@ public function load(array $configs, ContainerBuilder $container)
             $this->registerHtmlSanitizerConfiguration($config['html_sanitizer'], $container, $loader);
         }
 
+        if ($this->readConfigEnabled('ser_des', $container, $config['ser_des'])) {
+            $this->registerSerDesConfiguration($config['ser_des'], $container, $loader);
+        }
+
         $this->addAnnotatedClassesToCompile([
             '**\\Controller\\',
             '**\\Entity\\',
@@ -662,6 +670,10 @@ public function load(array $configs, ContainerBuilder $container)
             ->addTag('mime.mime_type_guesser');
         $container->registerForAutoconfiguration(LoggerAwareInterface::class)
             ->addMethodCall('setLogger', [new Reference('logger')]);
+        $container->registerForAutoconfiguration(SerializeContextBuilderInterface::class)
+            ->addTag('ser_des.context_builder.serialize');
+        $container->registerForAutoconfiguration(DeserializeContextBuilderInterface::class)
+            ->addTag('ser_des.context_builder.deserialize');
 
         $container->registerAttributeForAutoconfiguration(AsEventListener::class, static function (ChildDefinition $definition, AsEventListener $attribute, \ReflectionClass|\ReflectionMethod $reflector) {
             $tagAttributes = get_object_vars($attribute);
@@ -3043,6 +3055,27 @@ private function registerHtmlSanitizerConfiguration(array $config, ContainerBuil
         }
     }
 
+    private function registerSerDesConfiguration(array $config, ContainerBuilder $container, PhpFileLoader $loader): void
+    {
+        if (!interface_exists(SerDesSerializerInterface::class)) {
+            throw new LogicException('SerDes serializer support cannot be enabled as the SerDes component is not installed. Try running "composer require symfony/ser-des');
+        }
+
+        $container->setParameter('ser_des.serializable_paths', $config['serializable_paths']);
+        $container->setParameter('ser_des.template_warm_up.formats', $config['template_warm_up']['formats']);
+        $container->setParameter('ser_des.template_warm_up.max_variants', $config['template_warm_up']['max_variants']);
+
+        $loader->load('ser_des.php');
+
+        foreach ($config['serializable_paths'] as $path) {
+            if (!is_dir($path)) {
+                continue;
+            }
+
+            $container->fileExists($path, '/\.php$/');
+        }
+    }
+
     private function resolveTrustedHeaders(array $headers): int
     {
         $trustedHeaders = 0;

src/Symfony/Bundle/FrameworkBundle/Resources/config/cache.php

@@ -81,6 +81,11 @@
             ->private()
             ->tag('cache.pool')
 
+        ->set('cache.ser_des')
+            ->parent('cache.system')
+            ->private()
+            ->tag('cache.pool')
+
         ->set('cache.adapter.system', AdapterInterface::class)
             ->abstract()
             ->factory([AbstractAdapter::class, 'createSystemCache'])

src/Symfony/Bundle/FrameworkBundle/Resources/config/cache_debug.php

@@ -32,6 +32,7 @@
                 [
                     'cache.validator',
                     'cache.serializer',
+                    'cache.ser_des',
                 ],
             ])
             ->tag('kernel.cache_warmer', ['priority' => 64])