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

Open in your IDE?
  1. <?php
  2. namespace Doctrine\Bundle\DoctrineBundle\DependencyInjection;
  3. use Doctrine\Bundle\DoctrineBundle\Attribute\AsEntityListener;
  4. use Doctrine\Bundle\DoctrineBundle\CacheWarmer\DoctrineMetadataCacheWarmer;
  5. use Doctrine\Bundle\DoctrineBundle\Command\Proxy\ImportDoctrineCommand;
  6. use Doctrine\Bundle\DoctrineBundle\Dbal\ManagerRegistryAwareConnectionProvider;
  7. use Doctrine\Bundle\DoctrineBundle\Dbal\RegexSchemaAssetFilter;
  8. use Doctrine\Bundle\DoctrineBundle\DependencyInjection\Compiler\IdGeneratorPass;
  9. use Doctrine\Bundle\DoctrineBundle\DependencyInjection\Compiler\ServiceRepositoryCompilerPass;
  10. use Doctrine\Bundle\DoctrineBundle\EventSubscriber\EventSubscriberInterface;
  11. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepositoryInterface;
  12. use Doctrine\DBAL\Connection;
  13. use Doctrine\DBAL\Connections\PrimaryReadReplicaConnection;
  14. use Doctrine\DBAL\Logging\LoggerChain;
  15. use Doctrine\DBAL\Tools\Console\Command\ImportCommand;
  16. use Doctrine\DBAL\Tools\Console\ConnectionProvider;
  17. use Doctrine\ORM\EntityManagerInterface;
  18. use Doctrine\ORM\Id\AbstractIdGenerator;
  19. use Doctrine\ORM\Proxy\Autoloader;
  20. use Doctrine\ORM\UnitOfWork;
  21. use LogicException;
  22. use Symfony\Bridge\Doctrine\DependencyInjection\AbstractDoctrineExtension;
  23. use Symfony\Bridge\Doctrine\IdGenerator\UlidGenerator;
  24. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  25. use Symfony\Bridge\Doctrine\Messenger\DoctrineClearEntityManagerWorkerSubscriber;
  26. use Symfony\Bridge\Doctrine\Messenger\DoctrineTransactionMiddleware;
  27. use Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor;
  28. use Symfony\Bridge\Doctrine\SchemaListener\DoctrineDbalCacheAdapterSchemaSubscriber;
  29. use Symfony\Bridge\Doctrine\SchemaListener\MessengerTransportDoctrineSchemaSubscriber;
  30. use Symfony\Bridge\Doctrine\SchemaListener\PdoCacheAdapterDoctrineSchemaSubscriber;
  31. use Symfony\Bridge\Doctrine\SchemaListener\RememberMeTokenProviderDoctrineSchemaSubscriber;
  32. use Symfony\Bridge\Doctrine\Validator\DoctrineLoader;
  33. use Symfony\Component\Cache\Adapter\ArrayAdapter;
  34. use Symfony\Component\Cache\Adapter\PhpArrayAdapter;
  35. use Symfony\Component\Config\FileLocator;
  36. use Symfony\Component\DependencyInjection\Alias;
  37. use Symfony\Component\DependencyInjection\ChildDefinition;
  38. use Symfony\Component\DependencyInjection\ContainerBuilder;
  39. use Symfony\Component\DependencyInjection\Definition;
  40. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  41. use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
  42. use Symfony\Component\DependencyInjection\Reference;
  43. use Symfony\Component\Form\AbstractType;
  44. use Symfony\Component\Messenger\Bridge\Doctrine\Transport\DoctrineTransportFactory;
  45. use Symfony\Component\Messenger\MessageBusInterface;
  46. use Symfony\Component\PropertyInfo\PropertyInfoExtractorInterface;
  47. use Symfony\Component\Validator\Mapping\Loader\LoaderInterface;
  48. use function array_intersect_key;
  49. use function array_keys;
  50. use function class_exists;
  51. use function interface_exists;
  52. use function is_dir;
  53. use function method_exists;
  54. use function reset;
  55. use function sprintf;
  56. use function str_replace;
  57. /**
  58.  * DoctrineExtension is an extension for the Doctrine DBAL and ORM library.
  59.  */
  60. class DoctrineExtension extends AbstractDoctrineExtension
  61. {
  62.     /** @var string */
  63.     private $defaultConnection;
  64.     /**
  65.      * {@inheritDoc}
  66.      */
  67.     public function load(array $configs, ContainerBuilder $container)
  68.     {
  69.         $configuration = $this->getConfiguration($configs, $container);
  70.         $config        = $this->processConfiguration($configuration, $configs);
  71.         if (! empty($config['dbal'])) {
  72.             $this->dbalLoad($config['dbal'], $container);
  73.             $this->loadMessengerServices($container);
  74.         }
  75.         if (empty($config['orm'])) {
  76.             return;
  77.         }
  78.         if (empty($config['dbal'])) {
  79.             throw new LogicException('Configuring the ORM layer requires to configure the DBAL layer as well.');
  80.         }
  81.         $this->ormLoad($config['orm'], $container);
  82.     }
  83.     /**
  84.      * Loads the DBAL configuration.
  85.      *
  86.      * Usage example:
  87.      *
  88.      *      <doctrine:dbal id="myconn" dbname="sfweb" user="root" />
  89.      *
  90.      * @param array<string, mixed> $config    An array of configuration settings
  91.      * @param ContainerBuilder     $container A ContainerBuilder instance
  92.      */
  93.     protected function dbalLoad(array $config, ContainerBuilder $container)
  94.     {
  95.         $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
  96.         $loader->load('dbal.xml');
  97.         $chainLogger = $container->getDefinition('doctrine.dbal.logger.chain');
  98.         $logger      = new Reference('doctrine.dbal.logger');
  99.         $chainLogger->addArgument([$logger]);
  100.         if (class_exists(ImportCommand::class)) {
  101.             $container->register('doctrine.database_import_command', ImportDoctrineCommand::class)
  102.                 ->addTag('console.command', ['command' => 'doctrine:database:import']);
  103.         }
  104.         if (empty($config['default_connection'])) {
  105.             $keys                         = array_keys($config['connections']);
  106.             $config['default_connection'] = reset($keys);
  107.         }
  108.         $this->defaultConnection = $config['default_connection'];
  109.         $container->setAlias('database_connection', sprintf('doctrine.dbal.%s_connection', $this->defaultConnection));
  110.         $container->getAlias('database_connection')->setPublic(true);
  111.         $container->setAlias('doctrine.dbal.event_manager', new Alias(sprintf('doctrine.dbal.%s_connection.event_manager', $this->defaultConnection), false));
  112.         $container->setParameter('doctrine.dbal.connection_factory.types', $config['types']);
  113.         $connections = [];
  114.         foreach (array_keys($config['connections']) as $name) {
  115.             $connections[$name] = sprintf('doctrine.dbal.%s_connection', $name);
  116.         }
  117.         $container->setParameter('doctrine.connections', $connections);
  118.         $container->setParameter('doctrine.default_connection', $this->defaultConnection);
  119.         foreach ($config['connections'] as $name => $connection) {
  120.             $this->loadDbalConnection($name, $connection, $container);
  121.         }
  122.     }
  123.     /**
  124.      * Loads a configured DBAL connection.
  125.      *
  126.      * @param string               $name       The name of the connection
  127.      * @param array<string, mixed> $connection A dbal connection configuration.
  128.      * @param ContainerBuilder     $container  A ContainerBuilder instance
  129.      */
  130.     protected function loadDbalConnection($name, array $connection, ContainerBuilder $container)
  131.     {
  132.         $configuration = $container->setDefinition(sprintf('doctrine.dbal.%s_connection.configuration', $name), new ChildDefinition('doctrine.dbal.connection.configuration'));
  133.         $logger        = null;
  134.         if ($connection['logging']) {
  135.             $logger = new Reference('doctrine.dbal.logger');
  136.         }
  137.         unset($connection['logging']);
  138.         $dataCollectorDefinition = $container->getDefinition('data_collector.doctrine');
  139.         $dataCollectorDefinition->replaceArgument(1, $connection['profiling_collect_schema_errors']);
  140.         if ($connection['profiling']) {
  141.             $profilingAbstractId = $connection['profiling_collect_backtrace'] ?
  142.                 'doctrine.dbal.logger.backtrace' :
  143.                 'doctrine.dbal.logger.profiling';
  144.             $profilingLoggerId = $profilingAbstractId . '.' . $name;
  145.             $container->setDefinition($profilingLoggerId, new ChildDefinition($profilingAbstractId));
  146.             $profilingLogger = new Reference($profilingLoggerId);
  147.             $dataCollectorDefinition->addMethodCall('addLogger', [$name, $profilingLogger]);
  148.             if ($logger !== null) {
  149.                 $chainLogger = $container->register(
  150.                     'doctrine.dbal.logger.chain',
  151.                     LoggerChain::class
  152.                 );
  153.                 $chainLogger->addArgument([$logger, $profilingLogger]);
  154.                 $loggerId = 'doctrine.dbal.logger.chain.' . $name;
  155.                 $container->setDefinition($loggerId, $chainLogger);
  156.                 $logger = new Reference($loggerId);
  157.             } else {
  158.                 $logger = $profilingLogger;
  159.             }
  160.         }
  161.         unset(
  162.             $connection['profiling'],
  163.             $connection['profiling_collect_backtrace'],
  164.             $connection['profiling_collect_schema_errors']
  165.         );
  166.         if (isset($connection['auto_commit'])) {
  167.             $configuration->addMethodCall('setAutoCommit', [$connection['auto_commit']]);
  168.         }
  169.         unset($connection['auto_commit']);
  170.         if (isset($connection['schema_filter']) && $connection['schema_filter']) {
  171.             $definition = new Definition(RegexSchemaAssetFilter::class, [$connection['schema_filter']]);
  172.             $definition->addTag('doctrine.dbal.schema_filter', ['connection' => $name]);
  173.             $container->setDefinition(sprintf('doctrine.dbal.%s_regex_schema_filter', $name), $definition);
  174.         }
  175.         unset($connection['schema_filter']);
  176.         if ($logger) {
  177.             $configuration->addMethodCall('setSQLLogger', [$logger]);
  178.         }
  179.         // event manager
  180.         $container->setDefinition(sprintf('doctrine.dbal.%s_connection.event_manager', $name), new ChildDefinition('doctrine.dbal.connection.event_manager'));
  181.         // connection
  182.         $options = $this->getConnectionOptions($connection);
  183.         $connectionId = sprintf('doctrine.dbal.%s_connection', $name);
  184.         $def = $container
  185.             ->setDefinition($connectionId, new ChildDefinition('doctrine.dbal.connection'))
  186.             ->setPublic(true)
  187.             ->setArguments([
  188.                 $options,
  189.                 new Reference(sprintf('doctrine.dbal.%s_connection.configuration', $name)),
  190.                 new Reference(sprintf('doctrine.dbal.%s_connection.event_manager', $name)),
  191.                 $connection['mapping_types'],
  192.             ]);
  193.         $container
  194.             ->registerAliasForArgument($connectionId, Connection::class, sprintf('%sConnection', $name))
  195.             ->setPublic(false);
  196.         // Set class in case "wrapper_class" option was used to assist IDEs
  197.         if (isset($options['wrapperClass'])) {
  198.             $def->setClass($options['wrapperClass']);
  199.         }
  200.         if (! empty($connection['use_savepoints'])) {
  201.             $def->addMethodCall('setNestTransactionsWithSavepoints', [$connection['use_savepoints']]);
  202.         }
  203.         // Create a shard_manager for this connection
  204.         if (isset($options['shards'])) {
  205.             $shardManagerDefinition = new Definition($options['shardManagerClass'], [new Reference($connectionId)]);
  206.             $container->setDefinition(sprintf('doctrine.dbal.%s_shard_manager', $name), $shardManagerDefinition);
  207.         }
  208.         // dbal < 2.11 BC layer
  209.         if (! interface_exists(ConnectionProvider::class)) {
  210.             return;
  211.         }
  212.         $container->setDefinition(
  213.             ManagerRegistryAwareConnectionProvider::class,
  214.             new Definition(ManagerRegistryAwareConnectionProvider::class, [$container->getDefinition('doctrine')])
  215.         );
  216.     }
  217.     /**
  218.      * @param array<string, mixed> $connection
  219.      *
  220.      * @return mixed[]
  221.      */
  222.     protected function getConnectionOptions(array $connection): array
  223.     {
  224.         $options = $connection;
  225.         $connectionDefaults = [
  226.             'host' => 'localhost',
  227.             'port' => null,
  228.             'user' => 'root',
  229.             'password' => null,
  230.         ];
  231.         if ($options['override_url'] ?? false) {
  232.             $options['connection_override_options'] = array_intersect_key($options, ['dbname' => null] + $connectionDefaults);
  233.         }
  234.         unset($options['override_url']);
  235.         $options += $connectionDefaults;
  236.         foreach (['shards', 'replicas', 'slaves'] as $connectionKey) {
  237.             foreach (array_keys($options[$connectionKey]) as $name) {
  238.                 $options[$connectionKey][$name] += $connectionDefaults;
  239.             }
  240.         }
  241.         if (isset($options['platform_service'])) {
  242.             $options['platform'] = new Reference($options['platform_service']);
  243.             unset($options['platform_service']);
  244.         }
  245.         unset($options['mapping_types']);
  246.         if (isset($options['shard_choser_service'])) {
  247.             $options['shard_choser'] = new Reference($options['shard_choser_service']);
  248.             unset($options['shard_choser_service']);
  249.         }
  250.         foreach (
  251.             [
  252.                 'options' => 'driverOptions',
  253.                 'driver_class' => 'driverClass',
  254.                 'wrapper_class' => 'wrapperClass',
  255.                 'keep_slave' => 'keepReplica',
  256.                 'keep_replica' => 'keepReplica',
  257.                 'replicas' => 'replica',
  258.                 'shard_choser' => 'shardChoser',
  259.                 'shard_manager_class' => 'shardManagerClass',
  260.                 'server_version' => 'serverVersion',
  261.                 'default_table_options' => 'defaultTableOptions',
  262.             ] as $old => $new
  263.         ) {
  264.             if (! isset($options[$old])) {
  265.                 continue;
  266.             }
  267.             $options[$new] = $options[$old];
  268.             unset($options[$old]);
  269.         }
  270.         if (! empty($options['slaves']) && ! empty($options['replica']) && ! empty($options['shards'])) {
  271.             throw new InvalidArgumentException('Sharding and master-slave connection cannot be used together');
  272.         }
  273.         if (! empty($options['slaves']) || ! empty($options['replica'])) {
  274.             $nonRewrittenKeys = [
  275.                 'driver' => true,
  276.                 'driverOptions' => true,
  277.                 'driverClass' => true,
  278.                 'wrapperClass' => true,
  279.                 'keepSlave' => true,
  280.                 'keepReplica' => true,
  281.                 'shardChoser' => true,
  282.                 'platform' => true,
  283.                 'slaves' => true,
  284.                 'master' => true,
  285.                 'primary' => true,
  286.                 'replica' => true,
  287.                 'shards' => true,
  288.                 'serverVersion' => true,
  289.                 'defaultTableOptions' => true,
  290.                 // included by safety but should have been unset already
  291.                 'logging' => true,
  292.                 'profiling' => true,
  293.                 'mapping_types' => true,
  294.                 'platform_service' => true,
  295.             ];
  296.             foreach ($options as $key => $value) {
  297.                 if (isset($nonRewrittenKeys[$key])) {
  298.                     continue;
  299.                 }
  300.                 $options['primary'][$key] = $value;
  301.                 unset($options[$key]);
  302.             }
  303.             if (empty($options['wrapperClass'])) {
  304.                 // Change the wrapper class only if user did not configure custom one.
  305.                 $options['wrapperClass'] = PrimaryReadReplicaConnection::class;
  306.             }
  307.         } else {
  308.             unset($options['slaves'], $options['replica']);
  309.         }
  310.         if (! empty($options['shards'])) {
  311.             $nonRewrittenKeys = [
  312.                 'driver' => true,
  313.                 'driverOptions' => true,
  314.                 'driverClass' => true,
  315.                 'wrapperClass' => true,
  316.                 'keepSlave' => true,
  317.                 'keepReplica' => true,
  318.                 'shardChoser' => true,
  319.                 'platform' => true,
  320.                 'slaves' => true,
  321.                 'replica' => true,
  322.                 'global' => true,
  323.                 'shards' => true,
  324.                 'serverVersion' => true,
  325.                 'defaultTableOptions' => true,
  326.                 // included by safety but should have been unset already
  327.                 'logging' => true,
  328.                 'profiling' => true,
  329.                 'mapping_types' => true,
  330.                 'platform_service' => true,
  331.                 'shardManagerClass' => true,
  332.             ];
  333.             foreach ($options as $key => $value) {
  334.                 if (isset($nonRewrittenKeys[$key])) {
  335.                     continue;
  336.                 }
  337.                 $options['global'][$key] = $value;
  338.                 unset($options[$key]);
  339.             }
  340.             if (empty($options['wrapperClass'])) {
  341.                 // Change the wrapper class only if the user does not already forced using a custom one.
  342.                 $options['wrapperClass'] = 'Doctrine\\DBAL\\Sharding\\PoolingShardConnection';
  343.             }
  344.             if (empty($options['shardManagerClass'])) {
  345.                 // Change the shard manager class only if the user does not already forced using a custom one.
  346.                 $options['shardManagerClass'] = 'Doctrine\\DBAL\\Sharding\\PoolingShardManager';
  347.             }
  348.         } else {
  349.             unset($options['shards']);
  350.         }
  351.         return $options;
  352.     }
  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.         }
  368.         $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
  369.         $loader->load('orm.xml');
  370.         if (class_exists(AbstractType::class)) {
  371.             $container->getDefinition('form.type.entity')->addTag('kernel.reset', ['method' => 'reset']);
  372.         }
  373.         // available in Symfony 5.4 and higher
  374.         if (! class_exists(DoctrineDbalCacheAdapterSchemaSubscriber::class)) {
  375.             $container->removeDefinition('doctrine.orm.listeners.doctrine_dbal_cache_adapter_schema_subscriber');
  376.         }
  377.         // available in Symfony 5.1 and up to Symfony 5.4 (deprecated)
  378.         if (! class_exists(PdoCacheAdapterDoctrineSchemaSubscriber::class)) {
  379.             $container->removeDefinition('doctrine.orm.listeners.pdo_cache_adapter_doctrine_schema_subscriber');
  380.         }
  381.         // available in Symfony 5.3 and higher
  382.         if (! class_exists(RememberMeTokenProviderDoctrineSchemaSubscriber::class)) {
  383.             $container->removeDefinition('doctrine.orm.listeners.doctrine_token_provider_schema_subscriber');
  384.         }
  385.         if (! class_exists(UlidGenerator::class)) {
  386.             $container->removeDefinition('doctrine.ulid_generator');
  387.         }
  388.         if (! class_exists(UuidGenerator::class)) {
  389.             $container->removeDefinition('doctrine.uuid_generator');
  390.         }
  391.         $entityManagers = [];
  392.         foreach (array_keys($config['entity_managers']) as $name) {
  393.             $entityManagers[$name] = sprintf('doctrine.orm.%s_entity_manager', $name);
  394.         }
  395.         $container->setParameter('doctrine.entity_managers', $entityManagers);
  396.         if (empty($config['default_entity_manager'])) {
  397.             $tmp                              = array_keys($entityManagers);
  398.             $config['default_entity_manager'] = reset($tmp);
  399.         }
  400.         $container->setParameter('doctrine.default_entity_manager', $config['default_entity_manager']);
  401.         $options = ['auto_generate_proxy_classes', 'proxy_dir', 'proxy_namespace'];
  402.         foreach ($options as $key) {
  403.             $container->setParameter('doctrine.orm.' . $key, $config[$key]);
  404.         }
  405.         $container->setAlias('doctrine.orm.entity_manager', $defaultEntityManagerDefinitionId = sprintf('doctrine.orm.%s_entity_manager', $config['default_entity_manager']));
  406.         $container->getAlias('doctrine.orm.entity_manager')->setPublic(true);
  407.         $config['entity_managers'] = $this->fixManagersAutoMappings($config['entity_managers'], $container->getParameter('kernel.bundles'));
  408.         foreach ($config['entity_managers'] as $name => $entityManager) {
  409.             $entityManager['name'] = $name;
  410.             $this->loadOrmEntityManager($entityManager, $container);
  411.             if (interface_exists(PropertyInfoExtractorInterface::class)) {
  412.                 $this->loadPropertyInfoExtractor($name, $container);
  413.             }
  414.             if (! interface_exists(LoaderInterface::class)) {
  415.                 continue;
  416.             }
  417.             $this->loadValidatorLoader($name, $container);
  418.         }
  419.         if ($config['resolve_target_entities']) {
  420.             $def = $container->findDefinition('doctrine.orm.listeners.resolve_target_entity');
  421.             foreach ($config['resolve_target_entities'] as $name => $implementation) {
  422.                 $def->addMethodCall('addResolveTargetEntity', [
  423.                     $name,
  424.                     $implementation,
  425.                     [],
  426.                 ]);
  427.             }
  428.             $def->addTag('doctrine.event_subscriber');
  429.         }
  430.         $container->registerForAutoconfiguration(ServiceEntityRepositoryInterface::class)
  431.             ->addTag(ServiceRepositoryCompilerPass::REPOSITORY_SERVICE_TAG);
  432.         $container->registerForAutoconfiguration(EventSubscriberInterface::class)
  433.             ->addTag('doctrine.event_subscriber');
  434.         $container->registerForAutoconfiguration(AbstractIdGenerator::class)
  435.             ->addTag(IdGeneratorPass::ID_GENERATOR_TAG);
  436.         if (method_exists($container, 'registerAttributeForAutoconfiguration')) {
  437.             $container->registerAttributeForAutoconfiguration(AsEntityListener::class, static function (ChildDefinition $definition, AsEntityListener $attribute) {
  438.                 $definition->addTag('doctrine.orm.entity_listener', [
  439.                     'event'          => $attribute->event,
  440.                     'method'         => $attribute->method,
  441.                     'lazy'           => $attribute->lazy,
  442.                     'entity_manager' => $attribute->entityManager,
  443.                 ]);
  444.             });
  445.         }
  446.         /** @see DoctrineBundle::boot() */
  447.         $container->getDefinition($defaultEntityManagerDefinitionId)
  448.             ->addTag('container.preload', [
  449.                 'class' => Autoloader::class,
  450.             ]);
  451.     }
  452.     /**
  453.      * Loads a configured ORM entity manager.
  454.      *
  455.      * @param array<string, mixed> $entityManager A configured ORM entity manager.
  456.      * @param ContainerBuilder     $container     A ContainerBuilder instance
  457.      */
  458.     protected function loadOrmEntityManager(array $entityManager, ContainerBuilder $container)
  459.     {
  460.         $ormConfigDef = $container->setDefinition(sprintf('doctrine.orm.%s_configuration', $entityManager['name']), new ChildDefinition('doctrine.orm.configuration'));
  461.         $ormConfigDef->addTag(IdGeneratorPass::CONFIGURATION_TAG);
  462.         $this->loadOrmEntityManagerMappingInformation($entityManager, $ormConfigDef, $container);
  463.         $this->loadOrmCacheDrivers($entityManager, $container);
  464.         if (isset($entityManager['entity_listener_resolver']) && $entityManager['entity_listener_resolver']) {
  465.             $container->setAlias(sprintf('doctrine.orm.%s_entity_listener_resolver', $entityManager['name']), $entityManager['entity_listener_resolver']);
  466.         } else {
  467.             $definition = new Definition('%doctrine.orm.entity_listener_resolver.class%');
  468.             $definition->addArgument(new Reference('service_container'));
  469.             $container->setDefinition(sprintf('doctrine.orm.%s_entity_listener_resolver', $entityManager['name']), $definition);
  470.         }
  471.         $methods = [
  472.             'setMetadataCache' => new Reference(sprintf('doctrine.orm.%s_metadata_cache', $entityManager['name'])),
  473.             'setQueryCacheImpl' => new Reference(sprintf('doctrine.orm.%s_query_cache', $entityManager['name'])),
  474.             'setResultCacheImpl' => new Reference(sprintf('doctrine.orm.%s_result_cache', $entityManager['name'])),
  475.             'setMetadataDriverImpl' => new Reference('doctrine.orm.' . $entityManager['name'] . '_metadata_driver'),
  476.             'setProxyDir' => '%doctrine.orm.proxy_dir%',
  477.             'setProxyNamespace' => '%doctrine.orm.proxy_namespace%',
  478.             'setAutoGenerateProxyClasses' => '%doctrine.orm.auto_generate_proxy_classes%',
  479.             'setClassMetadataFactoryName' => $entityManager['class_metadata_factory_name'],
  480.             'setDefaultRepositoryClassName' => $entityManager['default_repository_class'],
  481.             'setNamingStrategy' => new Reference($entityManager['naming_strategy']),
  482.             'setQuoteStrategy' => new Reference($entityManager['quote_strategy']),
  483.             'setEntityListenerResolver' => new Reference(sprintf('doctrine.orm.%s_entity_listener_resolver', $entityManager['name'])),
  484.         ];
  485.         $listenerId        = sprintf('doctrine.orm.%s_listeners.attach_entity_listeners', $entityManager['name']);
  486.         $listenerDef       = $container->setDefinition($listenerId, new Definition('%doctrine.orm.listeners.attach_entity_listeners.class%'));
  487.         $listenerTagParams = ['event' => 'loadClassMetadata'];
  488.         if (isset($entityManager['connection'])) {
  489.             $listenerTagParams['connection'] = $entityManager['connection'];
  490.         }
  491.         $listenerDef->addTag('doctrine.event_listener', $listenerTagParams);
  492.         if (isset($entityManager['second_level_cache'])) {
  493.             $this->loadOrmSecondLevelCache($entityManager, $ormConfigDef, $container);
  494.         }
  495.         if ($entityManager['repository_factory']) {
  496.             $methods['setRepositoryFactory'] = new Reference($entityManager['repository_factory']);
  497.         }
  498.         foreach ($methods as $method => $arg) {
  499.             $ormConfigDef->addMethodCall($method, [$arg]);
  500.         }
  501.         foreach ($entityManager['hydrators'] as $name => $class) {
  502.             $ormConfigDef->addMethodCall('addCustomHydrationMode', [$name, $class]);
  503.         }
  504.         if (! empty($entityManager['dql'])) {
  505.             foreach ($entityManager['dql']['string_functions'] as $name => $function) {
  506.                 $ormConfigDef->addMethodCall('addCustomStringFunction', [$name, $function]);
  507.             }
  508.             foreach ($entityManager['dql']['numeric_functions'] as $name => $function) {
  509.                 $ormConfigDef->addMethodCall('addCustomNumericFunction', [$name, $function]);
  510.             }
  511.             foreach ($entityManager['dql']['datetime_functions'] as $name => $function) {
  512.                 $ormConfigDef->addMethodCall('addCustomDatetimeFunction', [$name, $function]);
  513.             }
  514.         }
  515.         $enabledFilters    = [];
  516.         $filtersParameters = [];
  517.         foreach ($entityManager['filters'] as $name => $filter) {
  518.             $ormConfigDef->addMethodCall('addFilter', [$name, $filter['class']]);
  519.             if ($filter['enabled']) {
  520.                 $enabledFilters[] = $name;
  521.             }
  522.             if (! $filter['parameters']) {
  523.                 continue;
  524.             }
  525.             $filtersParameters[$name] = $filter['parameters'];
  526.         }
  527.         $managerConfiguratorName = sprintf('doctrine.orm.%s_manager_configurator', $entityManager['name']);
  528.         $container
  529.             ->setDefinition($managerConfiguratorName, new ChildDefinition('doctrine.orm.manager_configurator.abstract'))
  530.             ->replaceArgument(0, $enabledFilters)
  531.             ->replaceArgument(1, $filtersParameters);
  532.         if (! isset($entityManager['connection'])) {
  533.             $entityManager['connection'] = $this->defaultConnection;
  534.         }
  535.         $entityManagerId = sprintf('doctrine.orm.%s_entity_manager', $entityManager['name']);
  536.         $container
  537.             ->setDefinition($entityManagerId, new ChildDefinition('doctrine.orm.entity_manager.abstract'))
  538.             ->setPublic(true)
  539.             ->setArguments([
  540.                 new Reference(sprintf('doctrine.dbal.%s_connection', $entityManager['connection'])),
  541.                 new Reference(sprintf('doctrine.orm.%s_configuration', $entityManager['name'])),
  542.             ])
  543.             ->setConfigurator([new Reference($managerConfiguratorName), 'configure']);
  544.         $container
  545.             ->registerAliasForArgument($entityManagerId, EntityManagerInterface::class, sprintf('%sEntityManager', $entityManager['name']))
  546.             ->setPublic(false);
  547.         $container->setAlias(
  548.             sprintf('doctrine.orm.%s_entity_manager.event_manager', $entityManager['name']),
  549.             new Alias(sprintf('doctrine.dbal.%s_connection.event_manager', $entityManager['connection']), false)
  550.         );
  551.         if (! isset($entityManager['entity_listeners'])) {
  552.             return;
  553.         }
  554.         $entities = $entityManager['entity_listeners']['entities'];
  555.         foreach ($entities as $entityListenerClass => $entity) {
  556.             foreach ($entity['listeners'] as $listenerClass => $listener) {
  557.                 foreach ($listener['events'] as $listenerEvent) {
  558.                     $listenerEventName = $listenerEvent['type'];
  559.                     $listenerMethod    = $listenerEvent['method'];
  560.                     $listenerDef->addMethodCall('addEntityListener', [
  561.                         $entityListenerClass,
  562.                         $listenerClass,
  563.                         $listenerEventName,
  564.                         $listenerMethod,
  565.                     ]);
  566.                 }
  567.             }
  568.         }
  569.     }
  570.     /**
  571.      * Loads an ORM entity managers bundle mapping information.
  572.      *
  573.      * There are two distinct configuration possibilities for mapping information:
  574.      *
  575.      * 1. Specify a bundle and optionally details where the entity and mapping information reside.
  576.      * 2. Specify an arbitrary mapping location.
  577.      *
  578.      * @param array<string, mixed> $entityManager A configured ORM entity manager
  579.      * @param Definition           $ormConfigDef  A Definition instance
  580.      * @param ContainerBuilder     $container     A ContainerBuilder instance
  581.      *
  582.      * @example
  583.      *
  584.      *  doctrine.orm:
  585.      *     mappings:
  586.      *         MyBundle1: ~
  587.      *         MyBundle2: yml
  588.      *         MyBundle3: { type: annotation, dir: Entities/ }
  589.      *         MyBundle4: { type: xml, dir: Resources/config/doctrine/mapping }
  590.      *         MyBundle5: { type: attribute, dir: Entities/ }
  591.      *         MyBundle6:
  592.      *             type: yml
  593.      *             dir: bundle-mappings/
  594.      *             alias: BundleAlias
  595.      *         arbitrary_key:
  596.      *             type: xml
  597.      *             dir: %kernel.project_dir%/src/vendor/DoctrineExtensions/lib/DoctrineExtensions/Entities
  598.      *             prefix: DoctrineExtensions\Entities\
  599.      *             alias: DExt
  600.      *
  601.      * In the case of bundles everything is really optional (which leads to autodetection for this bundle) but
  602.      * in the mappings key everything except alias is a required argument.
  603.      */
  604.     protected function loadOrmEntityManagerMappingInformation(array $entityManager, Definition $ormConfigDef, ContainerBuilder $container)
  605.     {
  606.         // reset state of drivers and alias map. They are only used by this methods and children.
  607.         $this->drivers  = [];
  608.         $this->aliasMap = [];
  609.         $this->loadMappingInformation($entityManager, $container);
  610.         $this->registerMappingDrivers($entityManager, $container);
  611.         $ormConfigDef->addMethodCall('setEntityNamespaces', [$this->aliasMap]);
  612.     }
  613.     /**
  614.      * Loads an ORM second level cache bundle mapping information.
  615.      *
  616.      * @param array<string, mixed> $entityManager A configured ORM entity manager
  617.      * @param Definition           $ormConfigDef  A Definition instance
  618.      * @param ContainerBuilder     $container     A ContainerBuilder instance
  619.      *
  620.      * @example
  621.      *  entity_managers:
  622.      *      default:
  623.      *          second_level_cache:
  624.      *              region_lifetime: 3600
  625.      *              region_lock_lifetime: 60
  626.      *              region_cache_driver: apc
  627.      *              log_enabled: true
  628.      *              regions:
  629.      *                  my_service_region:
  630.      *                      type: service
  631.      *                      service : "my_service_region"
  632.      *
  633.      *                  my_query_region:
  634.      *                      lifetime: 300
  635.      *                      cache_driver: array
  636.      *                      type: filelock
  637.      *
  638.      *                  my_entity_region:
  639.      *                      lifetime: 600
  640.      *                      cache_driver:
  641.      *                          type: apc
  642.      */
  643.     protected function loadOrmSecondLevelCache(array $entityManager, Definition $ormConfigDef, ContainerBuilder $container)
  644.     {
  645.         $driverId = null;
  646.         $enabled  = $entityManager['second_level_cache']['enabled'];
  647.         if (isset($entityManager['second_level_cache']['region_cache_driver'])) {
  648.             $driverName = 'second_level_cache.region_cache_driver';
  649.             $driverMap  = $entityManager['second_level_cache']['region_cache_driver'];
  650.             $driverId   = $this->loadCacheDriver($driverName, $entityManager['name'], $driverMap, $container);
  651.         }
  652.         $configId   = sprintf('doctrine.orm.%s_second_level_cache.cache_configuration', $entityManager['name']);
  653.         $regionsId  = sprintf('doctrine.orm.%s_second_level_cache.regions_configuration', $entityManager['name']);
  654.         $driverId   = $driverId ?: sprintf('doctrine.orm.%s_second_level_cache.region_cache_driver', $entityManager['name']);
  655.         $configDef  = $container->setDefinition($configId, new Definition('%doctrine.orm.second_level_cache.cache_configuration.class%'));
  656.         $regionsDef = $container
  657.             ->setDefinition($regionsId, new Definition('%doctrine.orm.second_level_cache.regions_configuration.class%'))
  658.             ->setArguments([$entityManager['second_level_cache']['region_lifetime'], $entityManager['second_level_cache']['region_lock_lifetime']]);
  659.         $slcFactoryId = sprintf('doctrine.orm.%s_second_level_cache.default_cache_factory', $entityManager['name']);
  660.         $factoryClass = $entityManager['second_level_cache']['factory'] ?? '%doctrine.orm.second_level_cache.default_cache_factory.class%';
  661.         $definition = new Definition($factoryClass, [new Reference($regionsId), new Reference($driverId)]);
  662.         $slcFactoryDef = $container
  663.             ->setDefinition($slcFactoryId, $definition);
  664.         if (isset($entityManager['second_level_cache']['regions'])) {
  665.             foreach ($entityManager['second_level_cache']['regions'] as $name => $region) {
  666.                 $regionRef  = null;
  667.                 $regionType = $region['type'];
  668.                 if ($regionType === 'service') {
  669.                     $regionId  = sprintf('doctrine.orm.%s_second_level_cache.region.%s', $entityManager['name'], $name);
  670.                     $regionRef = new Reference($region['service']);
  671.                     $container->setAlias($regionId, new Alias($region['service'], false));
  672.                 }
  673.                 if ($regionType === 'default' || $regionType === 'filelock') {
  674.                     $regionId   = sprintf('doctrine.orm.%s_second_level_cache.region.%s', $entityManager['name'], $name);
  675.                     $driverName = sprintf('second_level_cache.region.%s_driver', $name);
  676.                     $driverMap  = $region['cache_driver'];
  677.                     $driverId   = $this->loadCacheDriver($driverName, $entityManager['name'], $driverMap, $container);
  678.                     $regionRef  = new Reference($regionId);
  679.                     $container
  680.                         ->setDefinition($regionId, new Definition('%doctrine.orm.second_level_cache.default_region.class%'))
  681.                         ->setArguments([$name, new Reference($driverId), $region['lifetime']]);
  682.                 }
  683.                 if ($regionType === 'filelock') {
  684.                     $regionId = sprintf('doctrine.orm.%s_second_level_cache.region.%s_filelock', $entityManager['name'], $name);
  685.                     $container
  686.                         ->setDefinition($regionId, new Definition('%doctrine.orm.second_level_cache.filelock_region.class%'))
  687.                         ->setArguments([$regionRef, $region['lock_path'], $region['lock_lifetime']]);
  688.                     $regionRef = new Reference($regionId);
  689.                     $regionsDef->addMethodCall('getLockLifetime', [$name, $region['lock_lifetime']]);
  690.                 }
  691.                 $regionsDef->addMethodCall('setLifetime', [$name, $region['lifetime']]);
  692.                 $slcFactoryDef->addMethodCall('setRegion', [$regionRef]);
  693.             }
  694.         }
  695.         if ($entityManager['second_level_cache']['log_enabled']) {
  696.             $loggerChainId   = sprintf('doctrine.orm.%s_second_level_cache.logger_chain', $entityManager['name']);
  697.             $loggerStatsId   = sprintf('doctrine.orm.%s_second_level_cache.logger_statistics', $entityManager['name']);
  698.             $loggerChaingDef = $container->setDefinition($loggerChainId, new Definition('%doctrine.orm.second_level_cache.logger_chain.class%'));
  699.             $loggerStatsDef  = $container->setDefinition($loggerStatsId, new Definition('%doctrine.orm.second_level_cache.logger_statistics.class%'));
  700.             $loggerChaingDef->addMethodCall('setLogger', ['statistics', $loggerStatsDef]);
  701.             $configDef->addMethodCall('setCacheLogger', [$loggerChaingDef]);
  702.             foreach ($entityManager['second_level_cache']['loggers'] as $name => $logger) {
  703.                 $loggerId  = sprintf('doctrine.orm.%s_second_level_cache.logger.%s', $entityManager['name'], $name);
  704.                 $loggerRef = new Reference($logger['service']);
  705.                 $container->setAlias($loggerId, new Alias($logger['service'], false));
  706.                 $loggerChaingDef->addMethodCall('setLogger', [$name, $loggerRef]);
  707.             }
  708.         }
  709.         $configDef->addMethodCall('setCacheFactory', [$slcFactoryDef]);
  710.         $configDef->addMethodCall('setRegionsConfiguration', [$regionsDef]);
  711.         $ormConfigDef->addMethodCall('setSecondLevelCacheEnabled', [$enabled]);
  712.         $ormConfigDef->addMethodCall('setSecondLevelCacheConfiguration', [$configDef]);
  713.     }
  714.     /**
  715.      * {@inheritDoc}
  716.      */
  717.     protected function getObjectManagerElementName($name): string
  718.     {
  719.         return 'doctrine.orm.' . $name;
  720.     }
  721.     protected function getMappingObjectDefaultName(): string
  722.     {
  723.         return 'Entity';
  724.     }
  725.     protected function getMappingResourceConfigDirectory(?string $bundleDir = null): string
  726.     {
  727.         if ($bundleDir !== null && is_dir($bundleDir . '/config/doctrine')) {
  728.             return 'config/doctrine';
  729.         }
  730.         return 'Resources/config/doctrine';
  731.     }
  732.     protected function getMappingResourceExtension(): string
  733.     {
  734.         return 'orm';
  735.     }
  736.     /**
  737.      * {@inheritDoc}
  738.      */
  739.     protected function loadCacheDriver($cacheName, $objectManagerName, array $cacheDriver, ContainerBuilder $container): string
  740.     {
  741.         $aliasId = $this->getObjectManagerElementName(sprintf('%s_%s', $objectManagerName, $cacheName));
  742.         switch ($cacheDriver['type'] ?? 'pool') {
  743.             case 'service':
  744.                 $serviceId = $cacheDriver['id'];
  745.                 break;
  746.             case 'pool':
  747.                 $serviceId = $cacheDriver['pool'] ?? $this->createArrayAdapterCachePool($container, $objectManagerName, $cacheName);
  748.                 break;
  749.             default:
  750.                 throw new \InvalidArgumentException(sprintf(
  751.                     'Unknown cache of type "%s" configured for cache "%s" in entity manager "%s".',
  752.                     $cacheDriver['type'],
  753.                     $cacheName,
  754.                     $objectManagerName
  755.                 ));
  756.         }
  757.         $container->setAlias($aliasId, new Alias($serviceId, false));
  758.         return $aliasId;
  759.     }
  760.     /**
  761.      * Loads a configured entity managers cache drivers.
  762.      *
  763.      * @param array<string, mixed> $entityManager A configured ORM entity manager.
  764.      */
  765.     protected function loadOrmCacheDrivers(array $entityManager, ContainerBuilder $container)
  766.     {
  767.         if (isset($entityManager['metadata_cache_driver'])) {
  768.             $this->loadCacheDriver('metadata_cache', $entityManager['name'], $entityManager['metadata_cache_driver'], $container);
  769.         } else {
  770.             $this->createMetadataCache($entityManager['name'], $container);
  771.         }
  772.         $this->loadCacheDriver('result_cache', $entityManager['name'], $entityManager['result_cache_driver'], $container);
  773.         $this->loadCacheDriver('query_cache', $entityManager['name'], $entityManager['query_cache_driver'], $container);
  774.     }
  775.     private function createMetadataCache(string $objectManagerName, ContainerBuilder $container): void
  776.     {
  777.         $aliasId = $this->getObjectManagerElementName(sprintf('%s_%s', $objectManagerName, 'metadata_cache'));
  778.         $cacheId = sprintf('cache.doctrine.orm.%s.%s', $objectManagerName, 'metadata');
  779.         $cache = new Definition(ArrayAdapter::class);
  780.         if (! $container->getParameter('kernel.debug')) {
  781.             $phpArrayFile         = '%kernel.cache_dir%' . sprintf('/doctrine/orm/%s_metadata.php', $objectManagerName);
  782.             $cacheWarmerServiceId = $this->getObjectManagerElementName(sprintf('%s_%s', $objectManagerName, 'metadata_cache_warmer'));
  783.             $container->register($cacheWarmerServiceId, DoctrineMetadataCacheWarmer::class)
  784.                 ->setArguments([new Reference(sprintf('doctrine.orm.%s_entity_manager', $objectManagerName)), $phpArrayFile])
  785.                 ->addTag('kernel.cache_warmer', ['priority' => 1000]); // priority should be higher than ProxyCacheWarmer
  786.             $cache = new Definition(PhpArrayAdapter::class, [$phpArrayFile, $cache]);
  787.         }
  788.         $container->setDefinition($cacheId, $cache);
  789.         $container->setAlias($aliasId, $cacheId);
  790.     }
  791.     /**
  792.      * Loads a property info extractor for each defined entity manager.
  793.      */
  794.     private function loadPropertyInfoExtractor(string $entityManagerName, ContainerBuilder $container): void
  795.     {
  796.         $propertyExtractorDefinition = $container->register(sprintf('doctrine.orm.%s_entity_manager.property_info_extractor', $entityManagerName), DoctrineExtractor::class);
  797.         $argumentId                  = sprintf('doctrine.orm.%s_entity_manager', $entityManagerName);
  798.         $propertyExtractorDefinition->addArgument(new Reference($argumentId));
  799.         $propertyExtractorDefinition->addTag('property_info.list_extractor', ['priority' => -1001]);
  800.         $propertyExtractorDefinition->addTag('property_info.type_extractor', ['priority' => -999]);
  801.         $propertyExtractorDefinition->addTag('property_info.access_extractor', ['priority' => -999]);
  802.     }
  803.     /**
  804.      * Loads a validator loader for each defined entity manager.
  805.      */
  806.     private function loadValidatorLoader(string $entityManagerName, ContainerBuilder $container): void
  807.     {
  808.         $validatorLoaderDefinition = $container->register(sprintf('doctrine.orm.%s_entity_manager.validator_loader', $entityManagerName), DoctrineLoader::class);
  809.         $validatorLoaderDefinition->addArgument(new Reference(sprintf('doctrine.orm.%s_entity_manager', $entityManagerName)));
  810.         $validatorLoaderDefinition->addTag('validator.auto_mapper', ['priority' => -100]);
  811.     }
  812.     /**
  813.      * @param array<string, mixed> $objectManager
  814.      * @param string               $cacheName
  815.      *
  816.      * @psalm-suppress MoreSpecificImplementedParamType
  817.      */
  818.     public function loadObjectManagerCacheDriver(array $objectManager, ContainerBuilder $container, $cacheName)
  819.     {
  820.         $this->loadCacheDriver($cacheName, $objectManager['name'], $objectManager[$cacheName . '_driver'], $container);
  821.     }
  822.     public function getXsdValidationBasePath(): string
  823.     {
  824.         return __DIR__ . '/../Resources/config/schema';
  825.     }
  826.     public function getNamespace(): string
  827.     {
  828.         return 'http://symfony.com/schema/dic/doctrine';
  829.     }
  830.     /**
  831.      * {@inheritDoc}
  832.      */
  833.     public function getConfiguration(array $config, ContainerBuilder $container): Configuration
  834.     {
  835.         return new Configuration((bool) $container->getParameter('kernel.debug'));
  836.     }
  837.     protected function getMetadataDriverClass(string $driverType): string
  838.     {
  839.         return '%' . $this->getObjectManagerElementName('metadata.' . $driverType . '.class') . '%';
  840.     }
  841.     private function loadMessengerServices(ContainerBuilder $container): void
  842.     {
  843.         // If the Messenger component is installed and the doctrine transaction middleware is available, wire it:
  844.         /** @psalm-suppress UndefinedClass Optional dependency */
  845.         if (! interface_exists(MessageBusInterface::class) || ! class_exists(DoctrineTransactionMiddleware::class)) {
  846.             return;
  847.         }
  848.         $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
  849.         $loader->load('messenger.xml');
  850.         if (! class_exists(DoctrineClearEntityManagerWorkerSubscriber::class)) {
  851.             $container->removeDefinition('doctrine.orm.messenger.event_subscriber.doctrine_clear_entity_manager');
  852.         }
  853.         // available in Symfony 5.1 and higher
  854.         if (! class_exists(MessengerTransportDoctrineSchemaSubscriber::class)) {
  855.             $container->removeDefinition('doctrine.orm.messenger.doctrine_schema_subscriber');
  856.         }
  857.         $transportFactoryDefinition = $container->getDefinition('messenger.transport.doctrine.factory');
  858.         if (! class_exists(DoctrineTransportFactory::class)) {
  859.             // If symfony/messenger < 5.1
  860.             if (! class_exists(\Symfony\Component\Messenger\Transport\Doctrine\DoctrineTransportFactory::class)) {
  861.                 // Dont add the tag
  862.                 return;
  863.             }
  864.             $transportFactoryDefinition->setClass(\Symfony\Component\Messenger\Transport\Doctrine\DoctrineTransportFactory::class);
  865.         }
  866.         $transportFactoryDefinition->addTag('messenger.transport_factory');
  867.     }
  868.     private function createArrayAdapterCachePool(ContainerBuilder $container, string $objectManagerName, string $cacheName): string
  869.     {
  870.         $id = sprintf('cache.doctrine.orm.%s.%s', $objectManagerName, str_replace('_cache', '', $cacheName));
  871.         $poolDefinition = $container->register($id, ArrayAdapter::class);
  872.         $poolDefinition->addTag('cache.pool');
  873.         $container->setDefinition($id, $poolDefinition);
  874.         return $id;
  875.     }
  876. }