vendor/doctrine/doctrine-bundle/DependencyInjection/DoctrineExtension.php line 394

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