vendor/doctrine/doctrine-bundle/src/DependencyInjection/DoctrineExtension.php line 467

Open in your IDE?
  1. <?php
  2. namespace Doctrine\Bundle\DoctrineBundle\DependencyInjection;
  3. use Doctrine\Bundle\DoctrineBundle\Attribute\AsDoctrineListener;
  4. use Doctrine\Bundle\DoctrineBundle\Attribute\AsEntityListener;
  5. use Doctrine\Bundle\DoctrineBundle\Attribute\AsMiddleware;
  6. use Doctrine\Bundle\DoctrineBundle\CacheWarmer\DoctrineMetadataCacheWarmer;
  7. use Doctrine\Bundle\DoctrineBundle\ConnectionFactory;
  8. use Doctrine\Bundle\DoctrineBundle\Dbal\ManagerRegistryAwareConnectionProvider;
  9. use Doctrine\Bundle\DoctrineBundle\Dbal\RegexSchemaAssetFilter;
  10. use Doctrine\Bundle\DoctrineBundle\DependencyInjection\Compiler\IdGeneratorPass;
  11. use Doctrine\Bundle\DoctrineBundle\DependencyInjection\Compiler\ServiceRepositoryCompilerPass;
  12. use Doctrine\Bundle\DoctrineBundle\EventSubscriber\EventSubscriberInterface;
  13. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepositoryInterface;
  14. use Doctrine\Common\Annotations\Annotation;
  15. use Doctrine\DBAL\Connection;
  16. use Doctrine\DBAL\Connections\PrimaryReadReplicaConnection;
  17. use Doctrine\DBAL\Driver\Middleware as MiddlewareInterface;
  18. use Doctrine\DBAL\Schema\LegacySchemaManagerFactory;
  19. use Doctrine\ORM\Configuration as OrmConfiguration;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use Doctrine\ORM\Events;
  22. use Doctrine\ORM\Id\AbstractIdGenerator;
  23. use Doctrine\ORM\Mapping\Driver\SimplifiedXmlDriver;
  24. use Doctrine\ORM\Proxy\Autoloader;
  25. use Doctrine\ORM\Proxy\ProxyFactory;
  26. use Doctrine\ORM\Tools\Console\Command\ConvertMappingCommand;
  27. use Doctrine\ORM\Tools\Console\Command\EnsureProductionSettingsCommand;
  28. use Doctrine\ORM\Tools\Export\ClassMetadataExporter;
  29. use Doctrine\ORM\UnitOfWork;
  30. use Doctrine\Persistence\Reflection\RuntimeReflectionProperty;
  31. use InvalidArgumentException;
  32. use LogicException;
  33. use Symfony\Bridge\Doctrine\ArgumentResolver\EntityValueResolver;
  34. use Symfony\Bridge\Doctrine\Attribute\MapEntity;
  35. use Symfony\Bridge\Doctrine\DependencyInjection\AbstractDoctrineExtension;
  36. use Symfony\Bridge\Doctrine\IdGenerator\UlidGenerator;
  37. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  38. use Symfony\Bridge\Doctrine\Middleware\IdleConnection\Listener;
  39. use Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor;
  40. use Symfony\Bridge\Doctrine\SchemaListener\DoctrineDbalCacheAdapterSchemaListener;
  41. use Symfony\Bridge\Doctrine\SchemaListener\LockStoreSchemaListener;
  42. use Symfony\Bridge\Doctrine\SchemaListener\MessengerTransportDoctrineSchemaListener;
  43. use Symfony\Bridge\Doctrine\SchemaListener\PdoCacheAdapterDoctrineSchemaSubscriber;
  44. use Symfony\Bridge\Doctrine\SchemaListener\PdoSessionHandlerSchemaListener;
  45. use Symfony\Bridge\Doctrine\SchemaListener\RememberMeTokenProviderDoctrineSchemaListener;
  46. use Symfony\Bridge\Doctrine\Validator\DoctrineLoader;
  47. use Symfony\Component\Cache\Adapter\ArrayAdapter;
  48. use Symfony\Component\Cache\Adapter\PhpArrayAdapter;
  49. use Symfony\Component\Config\Definition\ConfigurationInterface;
  50. use Symfony\Component\Config\FileLocator;
  51. use Symfony\Component\DependencyInjection\Alias;
  52. use Symfony\Component\DependencyInjection\ChildDefinition;
  53. use Symfony\Component\DependencyInjection\ContainerBuilder;
  54. use Symfony\Component\DependencyInjection\Definition;
  55. use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
  56. use Symfony\Component\DependencyInjection\Reference;
  57. use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
  58. use Symfony\Component\Form\AbstractType;
  59. use Symfony\Component\Messenger\Bridge\Doctrine\Transport\DoctrineTransportFactory;
  60. use Symfony\Component\Messenger\MessageBusInterface;
  61. use Symfony\Component\PropertyInfo\PropertyInfoExtractorInterface;
  62. use Symfony\Component\Validator\Mapping\Loader\LoaderInterface;
  63. use Symfony\Component\VarExporter\LazyGhostTrait;
  64. use function array_intersect_key;
  65. use function array_keys;
  66. use function array_merge;
  67. use function class_exists;
  68. use function interface_exists;
  69. use function is_dir;
  70. use function method_exists;
  71. use function reset;
  72. use function sprintf;
  73. use function str_replace;
  74. use function trait_exists;
  75. use function trigger_deprecation;
  76. use const PHP_VERSION_ID;
  77. /**
  78.  * DoctrineExtension is an extension for the Doctrine DBAL and ORM library.
  79.  *
  80.  * @final since 2.9
  81.  * @psalm-type DBALConfig = array{
  82.  *      connections: array<string, array{logging: bool, profiling: bool, profiling_collect_backtrace: bool, idle_connection_ttl: int}>,
  83.  *      driver_schemes: array<string, string>,
  84.  *      default_connection: string,
  85.  *      types: array<string, string>,
  86.  *  }
  87.  */
  88. class DoctrineExtension extends AbstractDoctrineExtension
  89. {
  90.     private string $defaultConnection;
  91.     /**
  92.      * {@inheritDoc}
  93.      *
  94.      * @return void
  95.      */
  96.     public function load(array $configsContainerBuilder $container)
  97.     {
  98.         $configuration $this->getConfiguration($configs$container);
  99.         $config        $this->processConfigurationPrependingDefaults($configuration$configs);
  100.         if (! empty($config['dbal'])) {
  101.             $this->dbalLoad($config['dbal'], $container);
  102.             $this->loadMessengerServices($container);
  103.         }
  104.         if (empty($config['orm'])) {
  105.             return;
  106.         }
  107.         if (empty($config['dbal'])) {
  108.             throw new LogicException('Configuring the ORM layer requires to configure the DBAL layer as well.');
  109.         }
  110.         $this->ormLoad($config['orm'], $container);
  111.     }
  112.     /**
  113.      * Process user configuration and adds a default DBAL connection and/or a
  114.      * default EM if required, then process again the configuration to get
  115.      * default values for each.
  116.      *
  117.      * @param array<array<mixed>> $configs
  118.      *
  119.      * @return array<mixed>
  120.      */
  121.     private function processConfigurationPrependingDefaults(ConfigurationInterface $configuration, array $configs): array
  122.     {
  123.         $config      $this->processConfiguration($configuration$configs);
  124.         $configToAdd = [];
  125.         // if no DB connection defined, prepend an empty one for the default
  126.         // connection name in order to make Symfony Config resolve the default
  127.         // values
  128.         if (isset($config['dbal']) && empty($config['dbal']['connections'])) {
  129.             $configToAdd['dbal'] = ['connections' => [($config['dbal']['default_connection'] ?? 'default') => []]];
  130.         }
  131.         // if no EM defined, prepend an empty one for the default EM name in
  132.         // order to make Symfony Config resolve the default values
  133.         if (isset($config['orm']) && empty($config['orm']['entity_managers'])) {
  134.             $configToAdd['orm'] = ['entity_managers' => [($config['orm']['default_entity_manager'] ?? 'default') => []]];
  135.         }
  136.         if (! $configToAdd) {
  137.             return $config;
  138.         }
  139.         return $this->processConfiguration($configurationarray_merge([$configToAdd], $configs));
  140.     }
  141.     /**
  142.      * Loads the DBAL configuration.
  143.      *
  144.      * Usage example:
  145.      *
  146.      *      <doctrine:dbal id="myconn" dbname="sfweb" user="root" />
  147.      *
  148.      * @param DBALConfig       $config    An array of configuration settings
  149.      * @param ContainerBuilder $container A ContainerBuilder instance
  150.      */
  151.     protected function dbalLoad(array $configContainerBuilder $container)
  152.     {
  153.         $loader = new XmlFileLoader($container, new FileLocator(__DIR__ '/../../config'));
  154.         $loader->load('dbal.xml');
  155.         if (empty($config['default_connection'])) {
  156.             $keys                         array_keys($config['connections']);
  157.             $config['default_connection'] = reset($keys);
  158.         }
  159.         $this->defaultConnection $config['default_connection'];
  160.         $container->setAlias('database_connection'sprintf('doctrine.dbal.%s_connection'$this->defaultConnection));
  161.         $container->getAlias('database_connection')->setPublic(true);
  162.         $container->setAlias('doctrine.dbal.event_manager', new Alias(sprintf('doctrine.dbal.%s_connection.event_manager'$this->defaultConnection), false));
  163.         $container->setParameter('doctrine.dbal.connection_factory.types'$config['types']);
  164.         $container->getDefinition('doctrine.dbal.connection_factory.dsn_parser')->setArgument(0array_merge(ConnectionFactory::DEFAULT_SCHEME_MAP$config['driver_schemes']));
  165.         $connections = [];
  166.         foreach (array_keys($config['connections']) as $name) {
  167.             $connections[$name] = sprintf('doctrine.dbal.%s_connection'$name);
  168.         }
  169.         $container->setParameter('doctrine.connections'$connections);
  170.         $container->setParameter('doctrine.default_connection'$this->defaultConnection);
  171.         $connWithLogging   = [];
  172.         $connWithProfiling = [];
  173.         $connWithBacktrace = [];
  174.         $ttlByConnection   = [];
  175.         foreach ($config['connections'] as $name => $connection) {
  176.             if ($connection['logging']) {
  177.                 $connWithLogging[] = $name;
  178.             }
  179.             if ($connection['profiling']) {
  180.                 $connWithProfiling[] = $name;
  181.                 if ($connection['profiling_collect_backtrace']) {
  182.                     $connWithBacktrace[] = $name;
  183.                 }
  184.             }
  185.             if ($connection['idle_connection_ttl'] > 0) {
  186.                 $ttlByConnection[$name] = $connection['idle_connection_ttl'];
  187.             }
  188.             $this->loadDbalConnection($name$connection$container);
  189.         }
  190.         $container->registerForAutoconfiguration(MiddlewareInterface::class)->addTag('doctrine.middleware');
  191.         $container->registerAttributeForAutoconfiguration(AsMiddleware::class, static function (ChildDefinition $definitionAsMiddleware $attribute) {
  192.             $priority = isset($attribute->priority) ? ['priority' => $attribute->priority] : [];
  193.             if ($attribute->connections === []) {
  194.                 $definition->addTag('doctrine.middleware'$priority);
  195.                 return;
  196.             }
  197.             foreach ($attribute->connections as $connName) {
  198.                 $definition->addTag('doctrine.middleware'array_merge($priority, ['connection' => $connName]));
  199.             }
  200.         });
  201.         $this->registerDbalMiddlewares($container$connWithLogging$connWithProfiling$connWithBacktracearray_keys($ttlByConnection));
  202.         $container->getDefinition('doctrine.dbal.idle_connection_middleware')->setArgument(1$ttlByConnection);
  203.         if (class_exists(Listener::class)) {
  204.             return;
  205.         }
  206.         $container->removeDefinition('doctrine.dbal.idle_connection_listener');
  207.         $container->removeDefinition('doctrine.dbal.idle_connection_middleware');
  208.     }
  209.     /**
  210.      * Loads a configured DBAL connection.
  211.      *
  212.      * @param string               $name       The name of the connection
  213.      * @param array<string, mixed> $connection A dbal connection configuration.
  214.      * @param ContainerBuilder     $container  A ContainerBuilder instance
  215.      */
  216.     protected function loadDbalConnection($name, array $connectionContainerBuilder $container)
  217.     {
  218.         $configuration $container->setDefinition(sprintf('doctrine.dbal.%s_connection.configuration'$name), new ChildDefinition('doctrine.dbal.connection.configuration'));
  219.         unset($connection['logging']);
  220.         $dataCollectorDefinition $container->getDefinition('data_collector.doctrine');
  221.         $dataCollectorDefinition->replaceArgument(1$connection['profiling_collect_schema_errors']);
  222.         unset(
  223.             $connection['profiling'],
  224.             $connection['profiling_collect_backtrace'],
  225.             $connection['profiling_collect_schema_errors'],
  226.         );
  227.         if (isset($connection['auto_commit'])) {
  228.             $configuration->addMethodCall('setAutoCommit', [$connection['auto_commit']]);
  229.         }
  230.         unset($connection['auto_commit']);
  231.         if (isset($connection['disable_type_comments'])) {
  232.             $configuration->addMethodCall('setDisableTypeComments', [$connection['disable_type_comments']]);
  233.         }
  234.         unset($connection['disable_type_comments']);
  235.         if (isset($connection['schema_filter']) && $connection['schema_filter']) {
  236.             $definition = new Definition(RegexSchemaAssetFilter::class, [$connection['schema_filter']]);
  237.             $definition->addTag('doctrine.dbal.schema_filter', ['connection' => $name]);
  238.             $container->setDefinition(sprintf('doctrine.dbal.%s_regex_schema_filter'$name), $definition);
  239.         }
  240.         unset($connection['schema_filter']);
  241.         // event manager
  242.         $container->setDefinition(sprintf('doctrine.dbal.%s_connection.event_manager'$name), new ChildDefinition('doctrine.dbal.connection.event_manager'));
  243.         // connection
  244.         $options $this->getConnectionOptions($connection);
  245.         $connectionId sprintf('doctrine.dbal.%s_connection'$name);
  246.         $def $container
  247.             ->setDefinition($connectionId, new ChildDefinition('doctrine.dbal.connection'))
  248.             ->setPublic(true)
  249.             ->setArguments([
  250.                 $options,
  251.                 new Reference(sprintf('doctrine.dbal.%s_connection.configuration'$name)),
  252.                 // event manager is only supported on DBAL < 4
  253.                 method_exists(Connection::class, 'getEventManager') ? new Reference(sprintf('doctrine.dbal.%s_connection.event_manager'$name)) : null,
  254.                 $connection['mapping_types'],
  255.             ]);
  256.         $container
  257.             ->registerAliasForArgument($connectionIdConnection::class, sprintf('%sConnection'$name))
  258.             ->setPublic(false);
  259.         // Set class in case "wrapper_class" option was used to assist IDEs
  260.         if (isset($options['wrapperClass'])) {
  261.             $def->setClass($options['wrapperClass']);
  262.         }
  263.         if (isset($connection['use_savepoints'])) {
  264.             // DBAL >= 4 always has savepoints enabled. So we only need to call "setNestTransactionsWithSavepoints" for DBAL < 4
  265.             if (method_exists(Connection::class, 'getEventManager')) {
  266.                 if ($connection['use_savepoints']) {
  267.                     $def->addMethodCall('setNestTransactionsWithSavepoints', [$connection['use_savepoints']]);
  268.                 }
  269.             } elseif (! $connection['use_savepoints']) {
  270.                 throw new LogicException('The "use_savepoints" option can only be set to "true" and should ideally not be set when using DBAL >= 4');
  271.             }
  272.         }
  273.         $container->setDefinition(
  274.             ManagerRegistryAwareConnectionProvider::class,
  275.             new Definition(ManagerRegistryAwareConnectionProvider::class, [$container->getDefinition('doctrine')]),
  276.         );
  277.         $configuration->addMethodCall('setSchemaManagerFactory', [new Reference($connection['schema_manager_factory'])]);
  278.         if (isset($connection['result_cache'])) {
  279.             $configuration->addMethodCall('setResultCache', [new Reference($connection['result_cache'])]);
  280.         }
  281.         if (class_exists(LegacySchemaManagerFactory::class)) {
  282.             return;
  283.         }
  284.         $container->removeDefinition('doctrine.dbal.legacy_schema_manager_factory');
  285.     }
  286.     /**
  287.      * @param array<string, mixed> $connection
  288.      *
  289.      * @return mixed[]
  290.      */
  291.     protected function getConnectionOptions(array $connection): array
  292.     {
  293.         $options $connection;
  294.         $connectionDefaults = [
  295.             'host' => 'localhost',
  296.             'port' => null,
  297.             'user' => 'root',
  298.             'password' => null,
  299.         ];
  300.         if ($options['override_url'] ?? false) {
  301.             $options['connection_override_options'] = array_intersect_key($options, ['dbname' => null] + $connectionDefaults);
  302.         }
  303.         unset($options['override_url']);
  304.         unset($options['schema_manager_factory']);
  305.         $options += $connectionDefaults;
  306.         foreach (['replicas''slaves'] as $connectionKey) {
  307.             foreach (array_keys($options[$connectionKey]) as $name) {
  308.                 $options[$connectionKey][$name] += $connectionDefaults;
  309.             }
  310.         }
  311.         if (isset($options['platform_service'])) {
  312.             $options['platform'] = new Reference($options['platform_service']);
  313.             unset($options['platform_service']);
  314.         }
  315.         unset($options['mapping_types']);
  316.         foreach (
  317.             [
  318.                 'options' => 'driverOptions',
  319.                 'driver_class' => 'driverClass',
  320.                 'wrapper_class' => 'wrapperClass',
  321.                 'keep_slave' => 'keepReplica',
  322.                 'keep_replica' => 'keepReplica',
  323.                 'replicas' => 'replica',
  324.                 'server_version' => 'serverVersion',
  325.                 'default_table_options' => 'defaultTableOptions',
  326.             ] as $old => $new
  327.         ) {
  328.             if (! isset($options[$old])) {
  329.                 continue;
  330.             }
  331.             $options[$new] = $options[$old];
  332.             unset($options[$old]);
  333.         }
  334.         foreach (['replica''slaves'] as $connectionKey) {
  335.             foreach ($options[$connectionKey] as $name => $value) {
  336.                 $driverOptions       $value['driverOptions'] ?? [];
  337.                 $parentDriverOptions $options['driverOptions'] ?? [];
  338.                 if ($driverOptions === [] && $parentDriverOptions === []) {
  339.                     continue;
  340.                 }
  341.                 $options[$connectionKey][$name]['driverOptions'] = $driverOptions $parentDriverOptions;
  342.             }
  343.         }
  344.         if (! empty($options['slaves']) || ! empty($options['replica'])) {
  345.             $nonRewrittenKeys = [
  346.                 'driver' => true,
  347.                 'driverClass' => true,
  348.                 'wrapperClass' => true,
  349.                 'keepSlave' => true,
  350.                 'keepReplica' => true,
  351.                 'platform' => true,
  352.                 'slaves' => true,
  353.                 'primary' => true,
  354.                 'replica' => true,
  355.                 'serverVersion' => true,
  356.                 'defaultTableOptions' => true,
  357.                 // included by safety but should have been unset already
  358.                 'logging' => true,
  359.                 'profiling' => true,
  360.                 'mapping_types' => true,
  361.                 'platform_service' => true,
  362.             ];
  363.             foreach ($options as $key => $value) {
  364.                 if (isset($nonRewrittenKeys[$key])) {
  365.                     continue;
  366.                 }
  367.                 $options['primary'][$key] = $value;
  368.                 unset($options[$key]);
  369.             }
  370.             if (empty($options['wrapperClass'])) {
  371.                 // Change the wrapper class only if user did not configure custom one.
  372.                 $options['wrapperClass'] = PrimaryReadReplicaConnection::class;
  373.             }
  374.         } else {
  375.             unset($options['slaves'], $options['replica']);
  376.         }
  377.         return $options;
  378.     }
  379.     /**
  380.      * Loads the Doctrine ORM configuration.
  381.      *
  382.      * Usage example:
  383.      *
  384.      *     <doctrine:orm id="mydm" connection="myconn" />
  385.      *
  386.      * @param array<string, mixed> $config    An array of configuration settings
  387.      * @param ContainerBuilder     $container A ContainerBuilder instance
  388.      */
  389.     protected function ormLoad(array $configContainerBuilder $container)
  390.     {
  391.         if (! class_exists(UnitOfWork::class)) {
  392.             throw new LogicException('To configure the ORM layer, you must first install the doctrine/orm package.');
  393.         }
  394.         $loader = new XmlFileLoader($container, new FileLocator(__DIR__ '/../../config'));
  395.         $loader->load('orm.xml');
  396.         if (class_exists(AbstractType::class)) {
  397.             $container->getDefinition('form.type.entity')->addTag('kernel.reset', ['method' => 'reset']);
  398.         }
  399.         if (! class_exists(Annotation::class)) {
  400.             $container->removeAlias('doctrine.orm.metadata.annotation_reader');
  401.         }
  402.         // available in Symfony 6.3
  403.         $container->removeDefinition('doctrine.orm.listeners.doctrine_dbal_cache_adapter_schema_' . (class_exists(DoctrineDbalCacheAdapterSchemaListener::class) ? 'subscriber' 'listener'));
  404.         // available in Symfony 6.3
  405.         $container->removeDefinition('doctrine.orm.listeners.doctrine_token_provider_schema_' . (class_exists(RememberMeTokenProviderDoctrineSchemaListener::class) ? 'subscriber' 'listener'));
  406.         // available in Symfony 5.1 and up to Symfony 5.4 (deprecated)
  407.         if (! class_exists(PdoCacheAdapterDoctrineSchemaSubscriber::class)) {
  408.             $container->removeDefinition('doctrine.orm.listeners.pdo_cache_adapter_doctrine_schema_subscriber');
  409.         }
  410.         if (! class_exists(PdoSessionHandlerSchemaListener::class)) {
  411.             $container->removeDefinition('doctrine.orm.listeners.pdo_session_handler_schema_listener');
  412.         }
  413.         // available in Symfony 6.3 and higher
  414.         if (! class_exists(LockStoreSchemaListener::class)) {
  415.             $container->removeDefinition('doctrine.orm.listeners.lock_store_schema_listener');
  416.         }
  417.         if (! class_exists(UlidGenerator::class)) {
  418.             $container->removeDefinition('doctrine.ulid_generator');
  419.         }
  420.         if (! class_exists(UuidGenerator::class)) {
  421.             $container->removeDefinition('doctrine.uuid_generator');
  422.         }
  423.         // available in Symfony 6.2 and higher
  424.         if (! class_exists(EntityValueResolver::class)) {
  425.             $container->removeDefinition('doctrine.orm.entity_value_resolver');
  426.             $container->removeDefinition('doctrine.orm.entity_value_resolver.expression_language');
  427.         } else {
  428.             if (! class_exists(ExpressionLanguage::class)) {
  429.                 $container->removeDefinition('doctrine.orm.entity_value_resolver.expression_language');
  430.             }
  431.             $controllerResolverDefaults = [];
  432.             if (! $config['controller_resolver']['enabled']) {
  433.                 $controllerResolverDefaults['disabled'] = true;
  434.             }
  435.             if ($config['controller_resolver']['auto_mapping'] === null) {
  436.                 trigger_deprecation('doctrine/doctrine-bundle''2.12''The default value of "doctrine.orm.controller_resolver.auto_mapping" will be changed from `true` to `false`. Explicitly configure `true` to keep existing behaviour.');
  437.                 $config['controller_resolver']['auto_mapping'] = true;
  438.             }
  439.             if ($config['controller_resolver']['auto_mapping'] === true) {
  440.                 trigger_deprecation('doctrine/doctrine-bundle''2.13''Enabling the controller resolver automapping feature has been deprecated. Symfony Mapped Route Parameters should be used as replacement.');
  441.             }
  442.             if (! $config['controller_resolver']['auto_mapping']) {
  443.                 $controllerResolverDefaults['mapping'] = [];
  444.             }
  445.             if ($config['controller_resolver']['evict_cache']) {
  446.                 $controllerResolverDefaults['evict_cache'] = true;
  447.             }
  448.             if ($controllerResolverDefaults) {
  449.                 $container->getDefinition('doctrine.orm.entity_value_resolver')->setArgument(2, (new Definition(MapEntity::class))->setArguments([
  450.                     null,
  451.                     null,
  452.                     null,
  453.                     $controllerResolverDefaults['mapping'] ?? null,
  454.                     null,
  455.                     null,
  456.                     null,
  457.                     $controllerResolverDefaults['evict_cache'] ?? null,
  458.                     $controllerResolverDefaults['disabled'] ?? false,
  459.                 ]));
  460.             }
  461.         }
  462.         // not available in Doctrine ORM 3.0 and higher
  463.         if (! class_exists(ConvertMappingCommand::class)) {
  464.             $container->removeDefinition('doctrine.mapping_convert_command');
  465.         }
  466.         if (! class_exists(EnsureProductionSettingsCommand::class)) {
  467.             $container->removeDefinition('doctrine.ensure_production_settings_command');
  468.         }
  469.         if (! class_exists(ClassMetadataExporter::class)) {
  470.             $container->removeDefinition('doctrine.mapping_import_command');
  471.         }
  472.         $entityManagers = [];
  473.         foreach (array_keys($config['entity_managers']) as $name) {
  474.             /** @psalm-suppress InvalidArrayOffset */
  475.             $entityManagers[$name] = sprintf('doctrine.orm.%s_entity_manager'$name);
  476.         }
  477.         $container->setParameter('doctrine.entity_managers'$entityManagers);
  478.         if (empty($config['default_entity_manager'])) {
  479.             $tmp                              array_keys($entityManagers);
  480.             $config['default_entity_manager'] = reset($tmp);
  481.         }
  482.         $container->setParameter('doctrine.default_entity_manager'$config['default_entity_manager']);
  483.         if ($config['enable_lazy_ghost_objects'] ?? false) {
  484.             // available in Symfony 6.2 and higher
  485.             if (! trait_exists(LazyGhostTrait::class)) {
  486.                 throw new LogicException(
  487.                     'Lazy ghost objects cannot be enabled because the "symfony/var-exporter" library'
  488.                     ' version 6.2 or higher is not installed. Please run "composer require symfony/var-exporter:^6.2".',
  489.                 );
  490.             }
  491.             if (! class_exists(RuntimeReflectionProperty::class)) {
  492.                 throw new LogicException(
  493.                     'Lazy ghost objects cannot be enabled because the "doctrine/persistence" library'
  494.                     ' version 3.1 or higher is not installed. Please run "composer update doctrine/persistence".',
  495.                 );
  496.             }
  497.         } elseif (! method_exists(ProxyFactory::class, 'resetUninitializedProxy')) {
  498.             throw new LogicException(
  499.                 'Lazy ghost objects cannot be disabled for ORM 3.',
  500.             );
  501.         } elseif (PHP_VERSION_ID >= 80100) {
  502.             trigger_deprecation('doctrine/doctrine-bundle''2.11''Not setting "doctrine.orm.enable_lazy_ghost_objects" to true is deprecated.');
  503.         }
  504.         $options = ['auto_generate_proxy_classes''enable_lazy_ghost_objects''proxy_dir''proxy_namespace'];
  505.         foreach ($options as $key) {
  506.             $container->setParameter('doctrine.orm.' $key$config[$key]);
  507.         }
  508.         $container->setAlias('doctrine.orm.entity_manager'$defaultEntityManagerDefinitionId sprintf('doctrine.orm.%s_entity_manager'$config['default_entity_manager']));
  509.         $container->getAlias('doctrine.orm.entity_manager')->setPublic(true);
  510.         $config['entity_managers'] = $this->fixManagersAutoMappings($config['entity_managers'], $container->getParameter('kernel.bundles'));
  511.         foreach ($config['entity_managers'] as $name => $entityManager) {
  512.             $entityManager['name'] = $name;
  513.             $this->loadOrmEntityManager($entityManager$container);
  514.             if (interface_exists(PropertyInfoExtractorInterface::class)) {
  515.                 $this->loadPropertyInfoExtractor($name$container);
  516.             }
  517.             if (! interface_exists(LoaderInterface::class)) {
  518.                 continue;
  519.             }
  520.             $this->loadValidatorLoader($name$container);
  521.         }
  522.         if ($config['resolve_target_entities']) {
  523.             $def $container->findDefinition('doctrine.orm.listeners.resolve_target_entity');
  524.             foreach ($config['resolve_target_entities'] as $name => $implementation) {
  525.                 $def->addMethodCall('addResolveTargetEntity', [
  526.                     $name,
  527.                     $implementation,
  528.                     [],
  529.                 ]);
  530.             }
  531.             $def
  532.                 ->addTag('doctrine.event_listener', ['event' => Events::loadClassMetadata])
  533.                 ->addTag('doctrine.event_listener', ['event' => Events::onClassMetadataNotFound]);
  534.         }
  535.         $container->registerForAutoconfiguration(ServiceEntityRepositoryInterface::class)
  536.             ->addTag(ServiceRepositoryCompilerPass::REPOSITORY_SERVICE_TAG);
  537.         $container->registerForAutoconfiguration(EventSubscriberInterface::class)
  538.             ->addTag('doctrine.event_subscriber');
  539.         $container->registerForAutoconfiguration(AbstractIdGenerator::class)
  540.             ->addTag(IdGeneratorPass::ID_GENERATOR_TAG);
  541.         $container->registerAttributeForAutoconfiguration(AsEntityListener::class, static function (ChildDefinition $definitionAsEntityListener $attribute) {
  542.             $definition->addTag('doctrine.orm.entity_listener', [
  543.                 'event'          => $attribute->event,
  544.                 'method'         => $attribute->method,
  545.                 'lazy'           => $attribute->lazy,
  546.                 'entity_manager' => $attribute->entityManager,
  547.                 'entity'         => $attribute->entity,
  548.                 'priority'       => $attribute->priority,
  549.             ]);
  550.         });
  551.         $container->registerAttributeForAutoconfiguration(AsDoctrineListener::class, static function (ChildDefinition $definitionAsDoctrineListener $attribute) {
  552.             $definition->addTag('doctrine.event_listener', [
  553.                 'event'      => $attribute->event,
  554.                 'priority'   => $attribute->priority,
  555.                 'connection' => $attribute->connection,
  556.             ]);
  557.         });
  558.         /** @see DoctrineBundle::boot() */
  559.         $container->getDefinition($defaultEntityManagerDefinitionId)
  560.             ->addTag('container.preload', [
  561.                 'class' => Autoloader::class,
  562.             ]);
  563.     }
  564.     /**
  565.      * Loads a configured ORM entity manager.
  566.      *
  567.      * @param array<string, mixed> $entityManager A configured ORM entity manager.
  568.      * @param ContainerBuilder     $container     A ContainerBuilder instance
  569.      */
  570.     protected function loadOrmEntityManager(array $entityManagerContainerBuilder $container)
  571.     {
  572.         $ormConfigDef $container->setDefinition(sprintf('doctrine.orm.%s_configuration'$entityManager['name']), new ChildDefinition('doctrine.orm.configuration'));
  573.         $ormConfigDef->addTag(IdGeneratorPass::CONFIGURATION_TAG);
  574.         $this->loadOrmEntityManagerMappingInformation($entityManager$ormConfigDef$container);
  575.         $this->loadOrmCacheDrivers($entityManager$container);
  576.         if (isset($entityManager['entity_listener_resolver']) && $entityManager['entity_listener_resolver']) {
  577.             $container->setAlias(sprintf('doctrine.orm.%s_entity_listener_resolver'$entityManager['name']), $entityManager['entity_listener_resolver']);
  578.         } else {
  579.             $definition = new Definition('%doctrine.orm.entity_listener_resolver.class%');
  580.             $definition->addArgument(new Reference('service_container'));
  581.             $container->setDefinition(sprintf('doctrine.orm.%s_entity_listener_resolver'$entityManager['name']), $definition);
  582.         }
  583.         $methods = [
  584.             'setMetadataCache' => new Reference(sprintf('doctrine.orm.%s_metadata_cache'$entityManager['name'])),
  585.             'setQueryCache' => new Reference(sprintf('doctrine.orm.%s_query_cache'$entityManager['name'])),
  586.             'setResultCache' => new Reference(sprintf('doctrine.orm.%s_result_cache'$entityManager['name'])),
  587.             'setMetadataDriverImpl' => new Reference('doctrine.orm.' $entityManager['name'] . '_metadata_driver'),
  588.             'setProxyDir' => '%doctrine.orm.proxy_dir%',
  589.             'setProxyNamespace' => '%doctrine.orm.proxy_namespace%',
  590.             'setAutoGenerateProxyClasses' => '%doctrine.orm.auto_generate_proxy_classes%',
  591.             'setSchemaIgnoreClasses' => $entityManager['schema_ignore_classes'],
  592.             'setClassMetadataFactoryName' => $entityManager['class_metadata_factory_name'],
  593.             'setDefaultRepositoryClassName' => $entityManager['default_repository_class'],
  594.             'setNamingStrategy' => new Reference($entityManager['naming_strategy']),
  595.             'setQuoteStrategy' => new Reference($entityManager['quote_strategy']),
  596.             'setTypedFieldMapper' => new Reference($entityManager['typed_field_mapper']),
  597.             'setEntityListenerResolver' => new Reference(sprintf('doctrine.orm.%s_entity_listener_resolver'$entityManager['name'])),
  598.             'setLazyGhostObjectEnabled' => '%doctrine.orm.enable_lazy_ghost_objects%',
  599.             'setIdentityGenerationPreferences' => $entityManager['identity_generation_preferences'],
  600.         ];
  601.         if (! method_exists(OrmConfiguration::class, 'setLazyGhostObjectEnabled')) {
  602.             unset($methods['setLazyGhostObjectEnabled']);
  603.         }
  604.         $listenerId        sprintf('doctrine.orm.%s_listeners.attach_entity_listeners'$entityManager['name']);
  605.         $listenerDef       $container->setDefinition($listenerId, new Definition('%doctrine.orm.listeners.attach_entity_listeners.class%'));
  606.         $listenerTagParams = ['event' => 'loadClassMetadata'];
  607.         if (isset($entityManager['connection'])) {
  608.             $listenerTagParams['connection'] = $entityManager['connection'];
  609.         }
  610.         $listenerDef->addTag('doctrine.event_listener'$listenerTagParams);
  611.         if (isset($entityManager['second_level_cache'])) {
  612.             $this->loadOrmSecondLevelCache($entityManager$ormConfigDef$container);
  613.         }
  614.         if ($entityManager['repository_factory']) {
  615.             $methods['setRepositoryFactory'] = new Reference($entityManager['repository_factory']);
  616.         }
  617.         foreach ($methods as $method => $arg) {
  618.             $ormConfigDef->addMethodCall($method, [$arg]);
  619.         }
  620.         foreach ($entityManager['hydrators'] as $name => $class) {
  621.             $ormConfigDef->addMethodCall('addCustomHydrationMode', [$name$class]);
  622.         }
  623.         if (! empty($entityManager['dql'])) {
  624.             foreach ($entityManager['dql']['string_functions'] as $name => $function) {
  625.                 $ormConfigDef->addMethodCall('addCustomStringFunction', [$name$function]);
  626.             }
  627.             foreach ($entityManager['dql']['numeric_functions'] as $name => $function) {
  628.                 $ormConfigDef->addMethodCall('addCustomNumericFunction', [$name$function]);
  629.             }
  630.             foreach ($entityManager['dql']['datetime_functions'] as $name => $function) {
  631.                 $ormConfigDef->addMethodCall('addCustomDatetimeFunction', [$name$function]);
  632.             }
  633.         }
  634.         $enabledFilters    = [];
  635.         $filtersParameters = [];
  636.         foreach ($entityManager['filters'] as $name => $filter) {
  637.             $ormConfigDef->addMethodCall('addFilter', [$name$filter['class']]);
  638.             if ($filter['enabled']) {
  639.                 $enabledFilters[] = $name;
  640.             }
  641.             if (! $filter['parameters']) {
  642.                 continue;
  643.             }
  644.             $filtersParameters[$name] = $filter['parameters'];
  645.         }
  646.         $managerConfiguratorName sprintf('doctrine.orm.%s_manager_configurator'$entityManager['name']);
  647.         $container
  648.             ->setDefinition($managerConfiguratorName, new ChildDefinition('doctrine.orm.manager_configurator.abstract'))
  649.             ->replaceArgument(0$enabledFilters)
  650.             ->replaceArgument(1$filtersParameters);
  651.         if (! isset($entityManager['connection'])) {
  652.             $entityManager['connection'] = $this->defaultConnection;
  653.         }
  654.         $entityManagerId sprintf('doctrine.orm.%s_entity_manager'$entityManager['name']);
  655.         $container
  656.             ->setDefinition($entityManagerId, new ChildDefinition('doctrine.orm.entity_manager.abstract'))
  657.             ->setPublic(true)
  658.             ->setArguments([
  659.                 new Reference(sprintf('doctrine.dbal.%s_connection'$entityManager['connection'])),
  660.                 new Reference(sprintf('doctrine.orm.%s_configuration'$entityManager['name'])),
  661.                 new Reference(sprintf('doctrine.dbal.%s_connection.event_manager'$entityManager['connection'])),
  662.             ])
  663.             ->setConfigurator([new Reference($managerConfiguratorName), 'configure']);
  664.         $container
  665.             ->registerAliasForArgument($entityManagerIdEntityManagerInterface::class, sprintf('%sEntityManager'$entityManager['name']))
  666.             ->setPublic(false);
  667.         $container->setAlias(
  668.             sprintf('doctrine.orm.%s_entity_manager.event_manager'$entityManager['name']),
  669.             new Alias(sprintf('doctrine.dbal.%s_connection.event_manager'$entityManager['connection']), false),
  670.         );
  671.         if (! isset($entityManager['entity_listeners'])) {
  672.             return;
  673.         }
  674.         $entities $entityManager['entity_listeners']['entities'];
  675.         foreach ($entities as $entityListenerClass => $entity) {
  676.             foreach ($entity['listeners'] as $listenerClass => $listener) {
  677.                 foreach ($listener['events'] as $listenerEvent) {
  678.                     $listenerEventName $listenerEvent['type'];
  679.                     $listenerMethod    $listenerEvent['method'];
  680.                     $listenerDef->addMethodCall('addEntityListener', [
  681.                         $entityListenerClass,
  682.                         $listenerClass,
  683.                         $listenerEventName,
  684.                         $listenerMethod,
  685.                     ]);
  686.                 }
  687.             }
  688.         }
  689.     }
  690.     /**
  691.      * Loads an ORM entity managers bundle mapping information.
  692.      *
  693.      * There are two distinct configuration possibilities for mapping information:
  694.      *
  695.      * 1. Specify a bundle and optionally details where the entity and mapping information reside.
  696.      * 2. Specify an arbitrary mapping location.
  697.      *
  698.      * @param array<string, mixed> $entityManager A configured ORM entity manager
  699.      * @param Definition           $ormConfigDef  A Definition instance
  700.      * @param ContainerBuilder     $container     A ContainerBuilder instance
  701.      *
  702.      * @example
  703.      *
  704.      *  doctrine.orm:
  705.      *     mappings:
  706.      *         MyBundle1: ~
  707.      *         MyBundle2: yml
  708.      *         MyBundle3: { type: annotation, dir: Entities/ }
  709.      *         MyBundle4: { type: xml, dir: Resources/config/doctrine/mapping }
  710.      *         MyBundle5: { type: attribute, dir: Entities/ }
  711.      *         MyBundle6:
  712.      *             type: yml
  713.      *             dir: bundle-mappings/
  714.      *             alias: BundleAlias
  715.      *         arbitrary_key:
  716.      *             type: xml
  717.      *             dir: %kernel.project_dir%/src/vendor/DoctrineExtensions/lib/DoctrineExtensions/Entities
  718.      *             prefix: DoctrineExtensions\Entities\
  719.      *             alias: DExt
  720.      *
  721.      * In the case of bundles everything is really optional (which leads to autodetection for this bundle) but
  722.      * in the mappings key everything except alias is a required argument.
  723.      */
  724.     protected function loadOrmEntityManagerMappingInformation(array $entityManagerDefinition $ormConfigDefContainerBuilder $container)
  725.     {
  726.         // reset state of drivers and alias map. They are only used by this methods and children.
  727.         $this->drivers  = [];
  728.         $this->aliasMap = [];
  729.         $this->loadMappingInformation($entityManager$container);
  730.         $this->registerMappingDrivers($entityManager$container);
  731.         $container->getDefinition($this->getObjectManagerElementName($entityManager['name'] . '_metadata_driver'));
  732.         /** @psalm-suppress NoValue $this->drivers is set by $this->loadMappingInformation() call  */
  733.         foreach (array_keys($this->drivers) as $driverType) {
  734.             $mappingService   $this->getObjectManagerElementName($entityManager['name'] . '_' $driverType '_metadata_driver');
  735.             $mappingDriverDef $container->getDefinition($mappingService);
  736.             $args             $mappingDriverDef->getArguments();
  737.             if ($driverType === 'annotation') {
  738.                 $args[2] = $entityManager['report_fields_where_declared'];
  739.             } elseif ($driverType === 'attribute') {
  740.                 $args[1] = $entityManager['report_fields_where_declared'];
  741.             } elseif ($driverType === 'xml') {
  742.                 $args[1] ??= SimplifiedXmlDriver::DEFAULT_FILE_EXTENSION;
  743.                 $args[2]   = $entityManager['validate_xml_mapping'];
  744.             } else {
  745.                 continue;
  746.             }
  747.             $mappingDriverDef->setArguments($args);
  748.         }
  749.         $ormConfigDef->addMethodCall('setEntityNamespaces', [$this->aliasMap]);
  750.     }
  751.     /**
  752.      * Loads an ORM second level cache bundle mapping information.
  753.      *
  754.      * @param array<string, mixed> $entityManager A configured ORM entity manager
  755.      * @param Definition           $ormConfigDef  A Definition instance
  756.      * @param ContainerBuilder     $container     A ContainerBuilder instance
  757.      *
  758.      * @example
  759.      *  entity_managers:
  760.      *      default:
  761.      *          second_level_cache:
  762.      *              region_lifetime: 3600
  763.      *              region_lock_lifetime: 60
  764.      *              region_cache_driver: apc
  765.      *              log_enabled: true
  766.      *              regions:
  767.      *                  my_service_region:
  768.      *                      type: service
  769.      *                      service : "my_service_region"
  770.      *
  771.      *                  my_query_region:
  772.      *                      lifetime: 300
  773.      *                      cache_driver: array
  774.      *                      type: filelock
  775.      *
  776.      *                  my_entity_region:
  777.      *                      lifetime: 600
  778.      *                      cache_driver:
  779.      *                          type: apc
  780.      */
  781.     protected function loadOrmSecondLevelCache(array $entityManagerDefinition $ormConfigDefContainerBuilder $container)
  782.     {
  783.         $driverId null;
  784.         $enabled  $entityManager['second_level_cache']['enabled'];
  785.         if (isset($entityManager['second_level_cache']['region_cache_driver'])) {
  786.             $driverName 'second_level_cache.region_cache_driver';
  787.             $driverMap  $entityManager['second_level_cache']['region_cache_driver'];
  788.             $driverId   $this->loadCacheDriver($driverName$entityManager['name'], $driverMap$container);
  789.         }
  790.         $configId   sprintf('doctrine.orm.%s_second_level_cache.cache_configuration'$entityManager['name']);
  791.         $regionsId  sprintf('doctrine.orm.%s_second_level_cache.regions_configuration'$entityManager['name']);
  792.         $driverId   $driverId ?: sprintf('doctrine.orm.%s_second_level_cache.region_cache_driver'$entityManager['name']);
  793.         $configDef  $container->setDefinition($configId, new Definition('%doctrine.orm.second_level_cache.cache_configuration.class%'));
  794.         $regionsDef $container
  795.             ->setDefinition($regionsId, new Definition('%doctrine.orm.second_level_cache.regions_configuration.class%'))
  796.             ->setArguments([$entityManager['second_level_cache']['region_lifetime'], $entityManager['second_level_cache']['region_lock_lifetime']]);
  797.         $slcFactoryId sprintf('doctrine.orm.%s_second_level_cache.default_cache_factory'$entityManager['name']);
  798.         $factoryClass $entityManager['second_level_cache']['factory'] ?? '%doctrine.orm.second_level_cache.default_cache_factory.class%';
  799.         $definition = new Definition($factoryClass, [new Reference($regionsId), new Reference($driverId)]);
  800.         $slcFactoryDef $container
  801.             ->setDefinition($slcFactoryId$definition);
  802.         if (isset($entityManager['second_level_cache']['regions'])) {
  803.             foreach ($entityManager['second_level_cache']['regions'] as $name => $region) {
  804.                 $regionRef  null;
  805.                 $regionType $region['type'];
  806.                 if ($regionType === 'service') {
  807.                     $regionId  sprintf('doctrine.orm.%s_second_level_cache.region.%s'$entityManager['name'], $name);
  808.                     $regionRef = new Reference($region['service']);
  809.                     $container->setAlias($regionId, new Alias($region['service'], false));
  810.                 }
  811.                 if ($regionType === 'default' || $regionType === 'filelock') {
  812.                     $regionId   sprintf('doctrine.orm.%s_second_level_cache.region.%s'$entityManager['name'], $name);
  813.                     $driverName sprintf('second_level_cache.region.%s_driver'$name);
  814.                     $driverMap  $region['cache_driver'];
  815.                     $driverId   $this->loadCacheDriver($driverName$entityManager['name'], $driverMap$container);
  816.                     $regionRef  = new Reference($regionId);
  817.                     $container
  818.                         ->setDefinition($regionId, new Definition('%doctrine.orm.second_level_cache.default_region.class%'))
  819.                         ->setArguments([$name, new Reference($driverId), $region['lifetime']]);
  820.                 }
  821.                 if ($regionType === 'filelock') {
  822.                     $regionId sprintf('doctrine.orm.%s_second_level_cache.region.%s_filelock'$entityManager['name'], $name);
  823.                     $container
  824.                         ->setDefinition($regionId, new Definition('%doctrine.orm.second_level_cache.filelock_region.class%'))
  825.                         ->setArguments([$regionRef$region['lock_path'], $region['lock_lifetime']]);
  826.                     $regionRef = new Reference($regionId);
  827.                     $regionsDef->addMethodCall('getLockLifetime', [$name$region['lock_lifetime']]);
  828.                 }
  829.                 $regionsDef->addMethodCall('setLifetime', [$name$region['lifetime']]);
  830.                 $slcFactoryDef->addMethodCall('setRegion', [$regionRef]);
  831.             }
  832.         }
  833.         if ($entityManager['second_level_cache']['log_enabled']) {
  834.             $loggerChainId   sprintf('doctrine.orm.%s_second_level_cache.logger_chain'$entityManager['name']);
  835.             $loggerStatsId   sprintf('doctrine.orm.%s_second_level_cache.logger_statistics'$entityManager['name']);
  836.             $loggerChaingDef $container->setDefinition($loggerChainId, new Definition('%doctrine.orm.second_level_cache.logger_chain.class%'));
  837.             $loggerStatsDef  $container->setDefinition($loggerStatsId, new Definition('%doctrine.orm.second_level_cache.logger_statistics.class%'));
  838.             $loggerChaingDef->addMethodCall('setLogger', ['statistics'$loggerStatsDef]);
  839.             $configDef->addMethodCall('setCacheLogger', [$loggerChaingDef]);
  840.             foreach ($entityManager['second_level_cache']['loggers'] as $name => $logger) {
  841.                 $loggerId  sprintf('doctrine.orm.%s_second_level_cache.logger.%s'$entityManager['name'], $name);
  842.                 $loggerRef = new Reference($logger['service']);
  843.                 $container->setAlias($loggerId, new Alias($logger['service'], false));
  844.                 $loggerChaingDef->addMethodCall('setLogger', [$name$loggerRef]);
  845.             }
  846.         }
  847.         $configDef->addMethodCall('setCacheFactory', [$slcFactoryDef]);
  848.         $configDef->addMethodCall('setRegionsConfiguration', [$regionsDef]);
  849.         $ormConfigDef->addMethodCall('setSecondLevelCacheEnabled', [$enabled]);
  850.         $ormConfigDef->addMethodCall('setSecondLevelCacheConfiguration', [$configDef]);
  851.     }
  852.     /**
  853.      * {@inheritDoc}
  854.      */
  855.     protected function getObjectManagerElementName($name): string
  856.     {
  857.         return 'doctrine.orm.' $name;
  858.     }
  859.     protected function getMappingObjectDefaultName(): string
  860.     {
  861.         return 'Entity';
  862.     }
  863.     protected function getMappingResourceConfigDirectory(?string $bundleDir null): string
  864.     {
  865.         if ($bundleDir !== null && is_dir($bundleDir '/config/doctrine')) {
  866.             return 'config/doctrine';
  867.         }
  868.         return 'Resources/config/doctrine';
  869.     }
  870.     protected function getMappingResourceExtension(): string
  871.     {
  872.         return 'orm';
  873.     }
  874.     /**
  875.      * {@inheritDoc}
  876.      */
  877.     protected function loadCacheDriver($cacheName$objectManagerName, array $cacheDriverContainerBuilder $container): string
  878.     {
  879.         $aliasId $this->getObjectManagerElementName(sprintf('%s_%s'$objectManagerName$cacheName));
  880.         switch ($cacheDriver['type'] ?? 'pool') {
  881.             case 'service':
  882.                 $serviceId $cacheDriver['id'];
  883.                 break;
  884.             case 'pool':
  885.                 $serviceId $cacheDriver['pool'] ?? $this->createArrayAdapterCachePool($container$objectManagerName$cacheName);
  886.                 break;
  887.             default:
  888.                 throw new InvalidArgumentException(sprintf(
  889.                     'Unknown cache of type "%s" configured for cache "%s" in entity manager "%s".',
  890.                     $cacheDriver['type'],
  891.                     $cacheName,
  892.                     $objectManagerName,
  893.                 ));
  894.         }
  895.         $container->setAlias($aliasId, new Alias($serviceIdfalse));
  896.         return $aliasId;
  897.     }
  898.     /**
  899.      * Loads a configured entity managers cache drivers.
  900.      *
  901.      * @param array<string, mixed> $entityManager A configured ORM entity manager.
  902.      */
  903.     protected function loadOrmCacheDrivers(array $entityManagerContainerBuilder $container)
  904.     {
  905.         if (isset($entityManager['metadata_cache_driver'])) {
  906.             $this->loadCacheDriver('metadata_cache'$entityManager['name'], $entityManager['metadata_cache_driver'], $container);
  907.         } else {
  908.             $this->createMetadataCache($entityManager['name'], $container);
  909.         }
  910.         $this->loadCacheDriver('result_cache'$entityManager['name'], $entityManager['result_cache_driver'], $container);
  911.         $this->loadCacheDriver('query_cache'$entityManager['name'], $entityManager['query_cache_driver'], $container);
  912.     }
  913.     private function createMetadataCache(string $objectManagerNameContainerBuilder $container): void
  914.     {
  915.         $aliasId $this->getObjectManagerElementName(sprintf('%s_%s'$objectManagerName'metadata_cache'));
  916.         $cacheId sprintf('cache.doctrine.orm.%s.%s'$objectManagerName'metadata');
  917.         $cache = new Definition(ArrayAdapter::class);
  918.         if (! $container->getParameter('kernel.debug')) {
  919.             $phpArrayFile         '%kernel.cache_dir%' sprintf('/doctrine/orm/%s_metadata.php'$objectManagerName);
  920.             $cacheWarmerServiceId $this->getObjectManagerElementName(sprintf('%s_%s'$objectManagerName'metadata_cache_warmer'));
  921.             $container->register($cacheWarmerServiceIdDoctrineMetadataCacheWarmer::class)
  922.                 ->setArguments([new Reference(sprintf('doctrine.orm.%s_entity_manager'$objectManagerName)), $phpArrayFile])
  923.                 ->addTag('kernel.cache_warmer', ['priority' => 1000]); // priority should be higher than ProxyCacheWarmer
  924.             $cache = new Definition(PhpArrayAdapter::class, [$phpArrayFile$cache]);
  925.         }
  926.         $container->setDefinition($cacheId$cache);
  927.         $container->setAlias($aliasId$cacheId);
  928.     }
  929.     /**
  930.      * Loads a property info extractor for each defined entity manager.
  931.      */
  932.     private function loadPropertyInfoExtractor(string $entityManagerNameContainerBuilder $container): void
  933.     {
  934.         $propertyExtractorDefinition $container->register(sprintf('doctrine.orm.%s_entity_manager.property_info_extractor'$entityManagerName), DoctrineExtractor::class);
  935.         $argumentId                  sprintf('doctrine.orm.%s_entity_manager'$entityManagerName);
  936.         $propertyExtractorDefinition->addArgument(new Reference($argumentId));
  937.         $propertyExtractorDefinition->addTag('property_info.list_extractor', ['priority' => -1001]);
  938.         $propertyExtractorDefinition->addTag('property_info.type_extractor', ['priority' => -999]);
  939.         $propertyExtractorDefinition->addTag('property_info.access_extractor', ['priority' => -999]);
  940.     }
  941.     /**
  942.      * Loads a validator loader for each defined entity manager.
  943.      */
  944.     private function loadValidatorLoader(string $entityManagerNameContainerBuilder $container): void
  945.     {
  946.         $validatorLoaderDefinition $container->register(sprintf('doctrine.orm.%s_entity_manager.validator_loader'$entityManagerName), DoctrineLoader::class);
  947.         $validatorLoaderDefinition->addArgument(new Reference(sprintf('doctrine.orm.%s_entity_manager'$entityManagerName)));
  948.         $validatorLoaderDefinition->addTag('validator.auto_mapper', ['priority' => -100]);
  949.     }
  950.     public function getXsdValidationBasePath(): string
  951.     {
  952.         return __DIR__ '/../../config/schema';
  953.     }
  954.     public function getNamespace(): string
  955.     {
  956.         return 'http://symfony.com/schema/dic/doctrine';
  957.     }
  958.     /**
  959.      * {@inheritDoc}
  960.      */
  961.     public function getConfiguration(array $configContainerBuilder $container): Configuration
  962.     {
  963.         return new Configuration((bool) $container->getParameter('kernel.debug'));
  964.     }
  965.     protected function getMetadataDriverClass(string $driverType): string
  966.     {
  967.         return '%' $this->getObjectManagerElementName('metadata.' $driverType '.class') . '%';
  968.     }
  969.     private function loadMessengerServices(ContainerBuilder $container): void
  970.     {
  971.         // If the Messenger component is installed, wire it:
  972.         if (! interface_exists(MessageBusInterface::class)) {
  973.             return;
  974.         }
  975.         $loader = new XmlFileLoader($container, new FileLocator(__DIR__ '/../../config'));
  976.         $loader->load('messenger.xml');
  977.         // available in Symfony 6.3
  978.         $container->removeDefinition('doctrine.orm.messenger.doctrine_schema_' . (class_exists(MessengerTransportDoctrineSchemaListener::class) ? 'subscriber' 'listener'));
  979.         /**
  980.          * The Doctrine transport component (symfony/doctrine-messenger) is optional.
  981.          * Remove service definition, if it is not available
  982.          */
  983.         if (class_exists(DoctrineTransportFactory::class)) {
  984.             return;
  985.         }
  986.         $container->removeDefinition('messenger.transport.doctrine.factory');
  987.         $container->removeDefinition('doctrine.orm.messenger.doctrine_schema_subscriber');
  988.         $container->removeDefinition('doctrine.orm.messenger.doctrine_schema_listener');
  989.     }
  990.     private function createArrayAdapterCachePool(ContainerBuilder $containerstring $objectManagerNamestring $cacheName): string
  991.     {
  992.         $id sprintf('cache.doctrine.orm.%s.%s'$objectManagerNamestr_replace('_cache'''$cacheName));
  993.         $poolDefinition $container->register($idArrayAdapter::class);
  994.         $poolDefinition->addTag('cache.pool');
  995.         $container->setDefinition($id$poolDefinition);
  996.         return $id;
  997.     }
  998.     /**
  999.      * @param string[] $connWithLogging
  1000.      * @param string[] $connWithProfiling
  1001.      * @param string[] $connWithBacktrace
  1002.      * @param string[] $connWithTtl
  1003.      */
  1004.     private function registerDbalMiddlewares(
  1005.         ContainerBuilder $container,
  1006.         array $connWithLogging,
  1007.         array $connWithProfiling,
  1008.         array $connWithBacktrace,
  1009.         array $connWithTtl
  1010.     ): void {
  1011.         $loader = new XmlFileLoader($container, new FileLocator(__DIR__ '/../../config'));
  1012.         $loader->load('middlewares.xml');
  1013.         $loggingMiddlewareAbstractDef $container->getDefinition('doctrine.dbal.logging_middleware');
  1014.         foreach ($connWithLogging as $connName) {
  1015.             $loggingMiddlewareAbstractDef->addTag('doctrine.middleware', ['connection' => $connName'priority' => 10]);
  1016.         }
  1017.         $container->getDefinition('doctrine.debug_data_holder')->replaceArgument(0$connWithBacktrace);
  1018.         $debugMiddlewareAbstractDef $container->getDefinition('doctrine.dbal.debug_middleware');
  1019.         foreach ($connWithProfiling as $connName) {
  1020.             $debugMiddlewareAbstractDef
  1021.                 ->addTag('doctrine.middleware', ['connection' => $connName'priority' => 10]);
  1022.         }
  1023.         $idleConnectionMiddlewareAbstractDef $container->getDefinition('doctrine.dbal.idle_connection_middleware');
  1024.         foreach ($connWithTtl as $connName) {
  1025.             $idleConnectionMiddlewareAbstractDef
  1026.                 ->addTag('doctrine.middleware', ['connection' => $connName'priority' => 10]);
  1027.         }
  1028.     }
  1029. }