Initial commit

vendor/doctrine/doctrine-bundle/DependencyInjection/Compiler/DoctrineOrmMappingsPass.php

@@ -0,0 +1,155 @@
+<?php
+
+namespace Doctrine\Bundle\DoctrineBundle\DependencyInjection\Compiler;
+
+use Symfony\Bridge\Doctrine\DependencyInjection\CompilerPass\RegisterMappingsPass;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Class for Symfony bundles to configure mappings for model classes not in the
+ * auto-mapped folder.
+ *
+ * NOTE: alias is only supported by Symfony 2.6+ and will be ignored with older versions.
+ */
+class DoctrineOrmMappingsPass extends RegisterMappingsPass
+{
+    /**
+     * You should not directly instantiate this class but use one of the
+     * factory methods.
+     *
+     * @param Definition|Reference $driver            Driver DI definition or reference.
+     * @param array                $namespaces        List of namespaces handled by $driver.
+     * @param string[]             $managerParameters Ordered list of container parameters that
+     *                                                could hold the manager name.
+     *                                                doctrine.default_entity_manager is appended
+     *                                                automatically.
+     * @param string|false         $enabledParameter  If specified, the compiler pass only executes
+     *                                                if this parameter is defined in the service
+     *                                                container.
+     * @param array                $aliasMap          Map of alias to namespace.
+     */
+    public function __construct($driver, array $namespaces, array $managerParameters, $enabledParameter = false, array $aliasMap = [])
+    {
+        $managerParameters[] = 'doctrine.default_entity_manager';
+        parent::__construct(
+            $driver,
+            $namespaces,
+            $managerParameters,
+            'doctrine.orm.%s_metadata_driver',
+            $enabledParameter,
+            'doctrine.orm.%s_configuration',
+            'addEntityNamespace',
+            $aliasMap
+        );
+    }
+
+    /**
+     * @param array        $namespaces        Hashmap of directory path to namespace.
+     * @param string[]     $managerParameters List of parameters that could which object manager name
+     *                                        your bundle uses. This compiler pass will automatically
+     *                                        append the parameter name for the default entity manager
+     *                                        to this list.
+     * @param string|false $enabledParameter  Service container parameter that must be present to
+     *                                  enable the mapping. Set to false to not do any check,
+     *                                  optional.
+     * @param string[]     $aliasMap          Map of alias to namespace.
+     *
+     * @return self
+     */
+    public static function createXmlMappingDriver(array $namespaces, array $managerParameters = [], $enabledParameter = false, array $aliasMap = [])
+    {
+        $arguments = [$namespaces, '.orm.xml'];
+        $locator   = new Definition('Doctrine\Common\Persistence\Mapping\Driver\SymfonyFileLocator', $arguments);
+        $driver    = new Definition('Doctrine\ORM\Mapping\Driver\XmlDriver', [$locator]);
+
+        return new DoctrineOrmMappingsPass($driver, $namespaces, $managerParameters, $enabledParameter, $aliasMap);
+    }
+
+    /**
+     * @param array        $namespaces        Hashmap of directory path to namespace
+     * @param string[]     $managerParameters List of parameters that could which object manager name
+     *                                        your bundle uses. This compiler pass will automatically
+     *                                        append the parameter name for the default entity manager
+     *                                        to this list.
+     * @param string|false $enabledParameter  Service container parameter that must be present to
+     *                                  enable the mapping. Set to false to not do any check,
+     *                                  optional.
+     * @param string[]     $aliasMap          Map of alias to namespace.
+     *
+     * @return self
+     */
+    public static function createYamlMappingDriver(array $namespaces, array $managerParameters = [], $enabledParameter = false, array $aliasMap = [])
+    {
+        $arguments = [$namespaces, '.orm.yml'];
+        $locator   = new Definition('Doctrine\Common\Persistence\Mapping\Driver\SymfonyFileLocator', $arguments);
+        $driver    = new Definition('Doctrine\ORM\Mapping\Driver\YamlDriver', [$locator]);
+
+        return new DoctrineOrmMappingsPass($driver, $namespaces, $managerParameters, $enabledParameter, $aliasMap);
+    }
+
+    /**
+     * @param array    $namespaces        Hashmap of directory path to namespace
+     * @param string[] $managerParameters List of parameters that could which object manager name
+     *                                    your bundle uses. This compiler pass will automatically
+     *                                    append the parameter name for the default entity manager
+     *                                    to this list.
+     * @param string   $enabledParameter  Service container parameter that must be present to
+     *                                    enable the mapping. Set to false to not do any check,
+     *                                    optional.
+     * @param string[] $aliasMap          Map of alias to namespace.
+     *
+     * @return self
+     */
+    public static function createPhpMappingDriver(array $namespaces, array $managerParameters = [], $enabledParameter = false, array $aliasMap = [])
+    {
+        $arguments = [$namespaces, '.php'];
+        $locator   = new Definition('Doctrine\Common\Persistence\Mapping\Driver\SymfonyFileLocator', $arguments);
+        $driver    = new Definition('Doctrine\Common\Persistence\Mapping\Driver\PHPDriver', [$locator]);
+
+        return new DoctrineOrmMappingsPass($driver, $namespaces, $managerParameters, $enabledParameter, $aliasMap);
+    }
+
+    /**
+     * @param array        $namespaces        List of namespaces that are handled with annotation mapping
+     * @param array        $directories       List of directories to look for annotated classes
+     * @param string[]     $managerParameters List of parameters that could which object manager name
+     *                                        your bundle uses. This compiler pass will automatically
+     *                                        append the parameter name for the default entity manager
+     *                                        to this list.
+     * @param string|false $enabledParameter  Service container parameter that must be present to
+     *                                  enable the mapping. Set to false to not do any check,
+     *                                  optional.
+     * @param string[]     $aliasMap          Map of alias to namespace.
+     *
+     * @return self
+     */
+    public static function createAnnotationMappingDriver(array $namespaces, array $directories, array $managerParameters = [], $enabledParameter = false, array $aliasMap = [])
+    {
+        $reader = new Reference('annotation_reader');
+        $driver = new Definition('Doctrine\ORM\Mapping\Driver\AnnotationDriver', [$reader, $directories]);
+
+        return new DoctrineOrmMappingsPass($driver, $namespaces, $managerParameters, $enabledParameter, $aliasMap);
+    }
+
+    /**
+     * @param array        $namespaces        List of namespaces that are handled with static php mapping
+     * @param array        $directories       List of directories to look for static php mapping files
+     * @param string[]     $managerParameters List of parameters that could which object manager name
+     *                                        your bundle uses. This compiler pass will automatically
+     *                                        append the parameter name for the default entity manager
+     *                                        to this list.
+     * @param string|false $enabledParameter  Service container parameter that must be present to
+     *                                  enable the mapping. Set to false to not do any check,
+     *                                  optional.
+     * @param string[]     $aliasMap          Map of alias to namespace.
+     *
+     * @return self
+     */
+    public static function createStaticPhpMappingDriver(array $namespaces, array $directories, array $managerParameters = [], $enabledParameter = false, array $aliasMap = [])
+    {
+        $driver = new Definition('Doctrine\Common\Persistence\Mapping\Driver\StaticPHPDriver', [$directories]);
+
+        return new DoctrineOrmMappingsPass($driver, $namespaces, $managerParameters, $enabledParameter, $aliasMap);
+    }
+}

vendor/doctrine/doctrine-bundle/DependencyInjection/Compiler/EntityListenerPass.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace Doctrine\Bundle\DoctrineBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Class for Symfony bundles to register entity listeners
+ */
+class EntityListenerPass implements CompilerPassInterface
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $resolvers = $container->findTaggedServiceIds('doctrine.orm.entity_listener');
+
+        foreach ($resolvers as $id => $tagAttributes) {
+            foreach ($tagAttributes as $attributes) {
+                $name          = isset($attributes['entity_manager']) ? $attributes['entity_manager'] : $container->getParameter('doctrine.default_entity_manager');
+                $entityManager = sprintf('doctrine.orm.%s_entity_manager', $name);
+
+                if (! $container->hasDefinition($entityManager)) {
+                    continue;
+                }
+
+                $resolverId = sprintf('doctrine.orm.%s_entity_listener_resolver', $name);
+
+                if (! $container->has($resolverId)) {
+                    continue;
+                }
+
+                $resolver = $container->findDefinition($resolverId);
+                $resolver->setPublic(true);
+
+                if (isset($attributes['entity']) && isset($attributes['event'])) {
+                    $this->attachToListener($container, $name, $id, $attributes);
+                }
+
+                if (isset($attributes['lazy']) && $attributes['lazy']) {
+                    $listener = $container->findDefinition($id);
+
+                    if ($listener->isAbstract()) {
+                        throw new InvalidArgumentException(sprintf('The service "%s" must not be abstract as this entity listener is lazy-loaded.', $id));
+                    }
+
+                    $interface = 'Doctrine\\Bundle\\DoctrineBundle\\Mapping\\EntityListenerServiceResolver';
+                    $class     = $resolver->getClass();
+
+                    if (substr($class, 0, 1) === '%') {
+                        // resolve container parameter first
+                        $class = $container->getParameterBag()->resolveValue($resolver->getClass());
+                    }
+
+                    if (! is_a($class, $interface, true)) {
+                        throw new InvalidArgumentException(
+                            sprintf('Lazy-loaded entity listeners can only be resolved by a resolver implementing %s.', $interface)
+                        );
+                    }
+
+                    $listener->setPublic(true);
+
+                    $resolver->addMethodCall('registerService', [$listener->getClass(), $id]);
+                } else {
+                    $resolver->addMethodCall('register', [new Reference($id)]);
+                }
+            }
+        }
+    }
+
+    private function attachToListener(ContainerBuilder $container, $name, $id, array $attributes)
+    {
+        $listenerId = sprintf('doctrine.orm.%s_listeners.attach_entity_listeners', $name);
+
+        if (! $container->has($listenerId)) {
+            return;
+        }
+
+        $serviceDef = $container->getDefinition($id);
+
+        $args = [
+            $attributes['entity'],
+            $serviceDef->getClass(),
+            $attributes['event'],
+        ];
+
+        if (isset($attributes['method'])) {
+            $args[] = $attributes['method'];
+        }
+
+        $container->findDefinition($listenerId)->addMethodCall('addEntityListener', $args);
+    }
+}

vendor/doctrine/doctrine-bundle/DependencyInjection/Compiler/ServiceRepositoryCompilerPass.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Doctrine\Bundle\DoctrineBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\Compiler\ServiceLocatorTagPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Reference;
+
+final class ServiceRepositoryCompilerPass implements CompilerPassInterface
+{
+    const REPOSITORY_SERVICE_TAG = 'doctrine.repository_service';
+
+    public function process(ContainerBuilder $container)
+    {
+        // when ORM is not enabled
+        if (! $container->hasDefinition('doctrine.orm.container_repository_factory')) {
+            return;
+        }
+
+        $locatorDef = $container->getDefinition('doctrine.orm.container_repository_factory');
+
+        $repoServiceIds = array_keys($container->findTaggedServiceIds(self::REPOSITORY_SERVICE_TAG));
+
+        // Symfony 3.2 and lower sanity check
+        if (! class_exists(ServiceLocatorTagPass::class)) {
+            if (! empty($repoServiceIds)) {
+                throw new RuntimeException(sprintf('The "%s" tag can only be used with Symfony 3.3 or higher. Remove the tag from the following services (%s) or upgrade to Symfony 3.3 or higher.', self::REPOSITORY_SERVICE_TAG, implode(', ', $repoServiceIds)));
+            }
+
+            return;
+        }
+
+        $repoReferences = array_map(static function ($id) {
+            return new Reference($id);
+        }, $repoServiceIds);
+
+        $ref = ServiceLocatorTagPass::register($container, array_combine($repoServiceIds, $repoReferences));
+        $locatorDef->replaceArgument(0, $ref);
+    }
+}

vendor/doctrine/doctrine-bundle/DependencyInjection/Configuration.php

@@ -0,0 +1,739 @@
+<?php
+
+namespace Doctrine\Bundle\DoctrineBundle\DependencyInjection;
+
+use Doctrine\ORM\EntityManager;
+use ReflectionClass;
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+use Symfony\Component\Config\Definition\Builder\NodeDefinition;
+use Symfony\Component\Config\Definition\Builder\TreeBuilder;
+use Symfony\Component\Config\Definition\ConfigurationInterface;
+use Symfony\Component\DependencyInjection\Exception\LogicException;
+
+/**
+ * This class contains the configuration information for the bundle
+ *
+ * This information is solely responsible for how the different configuration
+ * sections are normalized, and merged.
+ */
+class Configuration implements ConfigurationInterface
+{
+    /** @var bool */
+    private $debug;
+
+    /**
+     * Constructor
+     *
+     * @param bool $debug Whether to use the debug mode
+     */
+    public function __construct($debug)
+    {
+        $this->debug = (bool) $debug;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getConfigTreeBuilder()
+    {
+        $treeBuilder = new TreeBuilder('doctrine');
+
+        if (method_exists($treeBuilder, 'getRootNode')) {
+            $rootNode = $treeBuilder->getRootNode();
+        } else {
+            // BC layer for symfony/config 4.1 and older
+            $rootNode = $treeBuilder->root('doctrine');
+        }
+
+        $this->addDbalSection($rootNode);
+        $this->addOrmSection($rootNode);
+
+        return $treeBuilder;
+    }
+
+    /**
+     * Add DBAL section to configuration tree
+     */
+    private function addDbalSection(ArrayNodeDefinition $node)
+    {
+        $node
+            ->children()
+            ->arrayNode('dbal')
+                ->beforeNormalization()
+                    ->ifTrue(static function ($v) {
+                        return is_array($v) && ! array_key_exists('connections', $v) && ! array_key_exists('connection', $v);
+                    })
+                    ->then(static function ($v) {
+                        // Key that should not be rewritten to the connection config
+                        $excludedKeys = ['default_connection' => true, 'types' => true, 'type' => true];
+                        $connection   = [];
+                        foreach ($v as $key => $value) {
+                            if (isset($excludedKeys[$key])) {
+                                continue;
+                            }
+                            $connection[$key] = $v[$key];
+                            unset($v[$key]);
+                        }
+                        $v['default_connection'] = isset($v['default_connection']) ? (string) $v['default_connection'] : 'default';
+                        $v['connections']        = [$v['default_connection'] => $connection];
+
+                        return $v;
+                    })
+                ->end()
+                ->children()
+                    ->scalarNode('default_connection')->end()
+                ->end()
+                ->fixXmlConfig('type')
+                ->children()
+                    ->arrayNode('types')
+                        ->useAttributeAsKey('name')
+                        ->prototype('array')
+                            ->beforeNormalization()
+                                ->ifString()
+                                ->then(static function ($v) {
+                                    return ['class' => $v];
+                                })
+                            ->end()
+                            ->children()
+                                ->scalarNode('class')->isRequired()->end()
+                                ->booleanNode('commented')->defaultTrue()->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                ->end()
+                ->fixXmlConfig('connection')
+                ->append($this->getDbalConnectionsNode())
+            ->end();
+    }
+
+    /**
+     * Return the dbal connections node
+     *
+     * @return ArrayNodeDefinition
+     */
+    private function getDbalConnectionsNode()
+    {
+        $treeBuilder = new TreeBuilder('connections');
+
+        if (method_exists($treeBuilder, 'getRootNode')) {
+            $node = $treeBuilder->getRootNode();
+        } else {
+            // BC layer for symfony/config 4.1 and older
+            $node = $treeBuilder->root('connections');
+        }
+
+        /** @var ArrayNodeDefinition $connectionNode */
+        $connectionNode = $node
+            ->requiresAtLeastOneElement()
+            ->useAttributeAsKey('name')
+            ->prototype('array');
+
+        $this->configureDbalDriverNode($connectionNode);
+
+        $connectionNode
+            ->fixXmlConfig('option')
+            ->fixXmlConfig('mapping_type')
+            ->fixXmlConfig('slave')
+            ->fixXmlConfig('shard')
+            ->fixXmlConfig('default_table_option')
+            ->children()
+                ->scalarNode('driver')->defaultValue('pdo_mysql')->end()
+                ->scalarNode('platform_service')->end()
+                ->booleanNode('auto_commit')->end()
+                ->scalarNode('schema_filter')->end()
+                ->booleanNode('logging')->defaultValue($this->debug)->end()
+                ->booleanNode('profiling')->defaultValue($this->debug)->end()
+                ->scalarNode('server_version')->end()
+                ->scalarNode('driver_class')->end()
+                ->scalarNode('wrapper_class')->end()
+                ->scalarNode('shard_manager_class')->end()
+                ->scalarNode('shard_choser')->end()
+                ->scalarNode('shard_choser_service')->end()
+                ->booleanNode('keep_slave')->end()
+                ->arrayNode('options')
+                    ->useAttributeAsKey('key')
+                    ->prototype('scalar')->end()
+                ->end()
+                ->arrayNode('mapping_types')
+                    ->useAttributeAsKey('name')
+                    ->prototype('scalar')->end()
+                ->end()
+                ->arrayNode('default_table_options')
+                    ->info("This option is used by the schema-tool and affects generated SQL. Possible keys include 'charset','collate', and 'engine'.")
+                    ->useAttributeAsKey('name')
+                    ->prototype('scalar')->end()
+                ->end()
+            ->end();
+
+        $slaveNode = $connectionNode
+            ->children()
+                ->arrayNode('slaves')
+                    ->useAttributeAsKey('name')
+                    ->prototype('array');
+        $this->configureDbalDriverNode($slaveNode);
+
+        $shardNode = $connectionNode
+            ->children()
+                ->arrayNode('shards')
+                    ->prototype('array')
+                    ->children()
+                        ->integerNode('id')
+                            ->min(1)
+                            ->isRequired()
+                        ->end()
+                    ->end();
+        $this->configureDbalDriverNode($shardNode);
+
+        return $node;
+    }
+
+    /**
+     * Adds config keys related to params processed by the DBAL drivers
+     *
+     * These keys are available for slave configurations too.
+     */
+    private function configureDbalDriverNode(ArrayNodeDefinition $node)
+    {
+        $node
+            ->children()
+                ->scalarNode('url')->info('A URL with connection information; any parameter value parsed from this string will override explicitly set parameters')->end()
+                ->scalarNode('dbname')->end()
+                ->scalarNode('host')->defaultValue('localhost')->end()
+                ->scalarNode('port')->defaultNull()->end()
+                ->scalarNode('user')->defaultValue('root')->end()
+                ->scalarNode('password')->defaultNull()->end()
+                ->scalarNode('application_name')->end()
+                ->scalarNode('charset')->end()
+                ->scalarNode('path')->end()
+                ->booleanNode('memory')->end()
+                ->scalarNode('unix_socket')->info('The unix socket to use for MySQL')->end()
+                ->booleanNode('persistent')->info('True to use as persistent connection for the ibm_db2 driver')->end()
+                ->scalarNode('protocol')->info('The protocol to use for the ibm_db2 driver (default to TCPIP if ommited)')->end()
+                ->booleanNode('service')
+                    ->info('True to use SERVICE_NAME as connection parameter instead of SID for Oracle')
+                ->end()
+                ->scalarNode('servicename')
+                    ->info(
+                        'Overrules dbname parameter if given and used as SERVICE_NAME or SID connection parameter ' .
+                        'for Oracle depending on the service parameter.'
+                    )
+                ->end()
+                ->scalarNode('sessionMode')
+                    ->info('The session mode to use for the oci8 driver')
+                ->end()
+                ->scalarNode('server')
+                    ->info('The name of a running database server to connect to for SQL Anywhere.')
+                ->end()
+                ->scalarNode('default_dbname')
+                    ->info(
+                        'Override the default database (postgres) to connect to for PostgreSQL connexion.'
+                    )
+                ->end()
+                ->scalarNode('sslmode')
+                    ->info(
+                        'Determines whether or with what priority a SSL TCP/IP connection will be negotiated with ' .
+                        'the server for PostgreSQL.'
+                    )
+                ->end()
+                ->scalarNode('sslrootcert')
+                    ->info(
+                        'The name of a file containing SSL certificate authority (CA) certificate(s). ' .
+                        'If the file exists, the server\'s certificate will be verified to be signed by one of these authorities.'
+                    )
+                ->end()
+                ->scalarNode('sslcert')
+                    ->info(
+                        'The path to the SSL client certificate file for PostgreSQL.'
+                    )
+                ->end()
+                ->scalarNode('sslkey')
+                    ->info(
+                        'The path to the SSL client key file for PostgreSQL.'
+                    )
+                ->end()
+                ->scalarNode('sslcrl')
+                    ->info(
+                        'The file name of the SSL certificate revocation list for PostgreSQL.'
+                    )
+                ->end()
+                ->booleanNode('pooled')->info('True to use a pooled server with the oci8/pdo_oracle driver')->end()
+                ->booleanNode('MultipleActiveResultSets')->info('Configuring MultipleActiveResultSets for the pdo_sqlsrv driver')->end()
+                ->booleanNode('use_savepoints')->info('Use savepoints for nested transactions')->end()
+                ->scalarNode('instancename')
+                ->info(
+                    'Optional parameter, complete whether to add the INSTANCE_NAME parameter in the connection.' .
+                    ' It is generally used to connect to an Oracle RAC server to select the name' .
+                    ' of a particular instance.'
+                )
+                ->end()
+                ->scalarNode('connectstring')
+                ->info(
+                    'Complete Easy Connect connection descriptor, see https://docs.oracle.com/database/121/NETAG/naming.htm.' .
+                    'When using this option, you will still need to provide the user and password parameters, but the other ' .
+                    'parameters will no longer be used. Note that when using this parameter, the getHost and getPort methods' .
+                    ' from Doctrine\DBAL\Connection will no longer function as expected.'
+                )
+                ->end()
+            ->end()
+            ->beforeNormalization()
+                ->ifTrue(static function ($v) {
+                    return ! isset($v['sessionMode']) && isset($v['session_mode']);
+                })
+                ->then(static function ($v) {
+                    $v['sessionMode'] = $v['session_mode'];
+                    unset($v['session_mode']);
+
+                    return $v;
+                })
+            ->end()
+            ->beforeNormalization()
+                ->ifTrue(static function ($v) {
+                    return ! isset($v['MultipleActiveResultSets']) && isset($v['multiple_active_result_sets']);
+                })
+                ->then(static function ($v) {
+                    $v['MultipleActiveResultSets'] = $v['multiple_active_result_sets'];
+                    unset($v['multiple_active_result_sets']);
+
+                    return $v;
+                })
+            ->end();
+    }
+
+    /**
+     * Add the ORM section to configuration tree
+     */
+    private function addOrmSection(ArrayNodeDefinition $node)
+    {
+        $node
+            ->children()
+                ->arrayNode('orm')
+                    ->beforeNormalization()
+                        ->ifTrue(static function ($v) {
+                            if (! empty($v) && ! class_exists(EntityManager::class)) {
+                                throw new LogicException('The doctrine/orm package is required when the doctrine.orm config is set.');
+                            }
+
+                            return $v === null || (is_array($v) && ! array_key_exists('entity_managers', $v) && ! array_key_exists('entity_manager', $v));
+                        })
+                        ->then(static function ($v) {
+                            $v = (array) $v;
+                            // Key that should not be rewritten to the connection config
+                            $excludedKeys  = [
+                                'default_entity_manager' => true,
+                                'auto_generate_proxy_classes' => true,
+                                'proxy_dir' => true,
+                                'proxy_namespace' => true,
+                                'resolve_target_entities' => true,
+                                'resolve_target_entity' => true,
+                            ];
+                            $entityManager = [];
+                            foreach ($v as $key => $value) {
+                                if (isset($excludedKeys[$key])) {
+                                    continue;
+                                }
+                                $entityManager[$key] = $v[$key];
+                                unset($v[$key]);
+                            }
+                            $v['default_entity_manager'] = isset($v['default_entity_manager']) ? (string) $v['default_entity_manager'] : 'default';
+                            $v['entity_managers']        = [$v['default_entity_manager'] => $entityManager];
+
+                            return $v;
+                        })
+                    ->end()
+                    ->children()
+                        ->scalarNode('default_entity_manager')->end()
+                        ->scalarNode('auto_generate_proxy_classes')->defaultValue(false)
+                            ->info('Auto generate mode possible values are: "NEVER", "ALWAYS", "FILE_NOT_EXISTS", "EVAL"')
+                            ->validate()
+                                ->ifTrue(function ($v) {
+                                    $generationModes = $this->getAutoGenerateModes();
+
+                                    if (is_int($v) && in_array($v, $generationModes['values']/*array(0, 1, 2, 3)*/)) {
+                                        return false;
+                                    }
+                                    if (is_bool($v)) {
+                                        return false;
+                                    }
+                                    if (is_string($v)) {
+                                        if (in_array(strtoupper($v), $generationModes['names']/*array('NEVER', 'ALWAYS', 'FILE_NOT_EXISTS', 'EVAL')*/)) {
+                                            return false;
+                                        }
+                                    }
+
+                                    return true;
+                                })
+                                ->thenInvalid('Invalid auto generate mode value %s')
+                            ->end()
+                            ->validate()
+                                ->ifString()
+                                ->then(static function ($v) {
+                                    return constant('Doctrine\Common\Proxy\AbstractProxyFactory::AUTOGENERATE_' . strtoupper($v));
+                                })
+                            ->end()
+                        ->end()
+                        ->scalarNode('proxy_dir')->defaultValue('%kernel.cache_dir%/doctrine/orm/Proxies')->end()
+                        ->scalarNode('proxy_namespace')->defaultValue('Proxies')->end()
+                    ->end()
+                    ->fixXmlConfig('entity_manager')
+                    ->append($this->getOrmEntityManagersNode())
+                    ->fixXmlConfig('resolve_target_entity', 'resolve_target_entities')
+                    ->append($this->getOrmTargetEntityResolverNode())
+                ->end()
+            ->end();
+    }
+
+    /**
+     * Return ORM target entity resolver node
+     *
+     * @return NodeDefinition
+     */
+    private function getOrmTargetEntityResolverNode()
+    {
+        $treeBuilder = new TreeBuilder('resolve_target_entities');
+
+        if (method_exists($treeBuilder, 'getRootNode')) {
+            $node = $treeBuilder->getRootNode();
+        } else {
+            // BC layer for symfony/config 4.1 and older
+            $node = $treeBuilder->root('resolve_target_entities');
+        }
+
+        $node
+            ->useAttributeAsKey('interface')
+            ->prototype('scalar')
+                ->cannotBeEmpty()
+            ->end();
+
+        return $node;
+    }
+
+    /**
+     * Return ORM entity listener node
+     *
+     * @return NodeDefinition
+     */
+    private function getOrmEntityListenersNode()
+    {
+        $treeBuilder = new TreeBuilder('entity_listeners');
+
+        if (method_exists($treeBuilder, 'getRootNode')) {
+            $node = $treeBuilder->getRootNode();
+        } else {
+            // BC layer for symfony/config 4.1 and older
+            $node = $treeBuilder->root('entity_listeners');
+        }
+
+        $normalizer = static function ($mappings) {
+            $entities = [];
+
+            foreach ($mappings as $entityClass => $mapping) {
+                $listeners = [];
+
+                foreach ($mapping as $listenerClass => $listenerEvent) {
+                    $events = [];
+
+                    foreach ($listenerEvent as $eventType => $eventMapping) {
+                        if ($eventMapping === null) {
+                            $eventMapping = [null];
+                        }
+
+                        foreach ($eventMapping as $method) {
+                            $events[] = [
+                                'type' => $eventType,
+                                'method' => $method,
+                            ];
+                        }
+                    }
+
+                    $listeners[] = [
+                        'class' => $listenerClass,
+                        'event' => $events,
+                    ];
+                }
+
+                $entities[] = [
+                    'class' => $entityClass,
+                    'listener' => $listeners,
+                ];
+            }
+
+            return ['entities' => $entities];
+        };
+
+        $node
+            ->beforeNormalization()
+                // Yaml normalization
+                ->ifTrue(static function ($v) {
+                    return is_array(reset($v)) && is_string(key(reset($v)));
+                })
+                ->then($normalizer)
+            ->end()
+            ->fixXmlConfig('entity', 'entities')
+            ->children()
+                ->arrayNode('entities')
+                    ->useAttributeAsKey('class')
+                    ->prototype('array')
+                        ->fixXmlConfig('listener')
+                        ->children()
+                            ->arrayNode('listeners')
+                                ->useAttributeAsKey('class')
+                                ->prototype('array')
+                                    ->fixXmlConfig('event')
+                                    ->children()
+                                        ->arrayNode('events')
+                                            ->prototype('array')
+                                                ->children()
+                                                    ->scalarNode('type')->end()
+                                                    ->scalarNode('method')->defaultNull()->end()
+                                                ->end()
+                                            ->end()
+                                        ->end()
+                                    ->end()
+                                ->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                ->end()
+            ->end();
+
+        return $node;
+    }
+
+    /**
+     * Return ORM entity manager node
+     *
+     * @return ArrayNodeDefinition
+     */
+    private function getOrmEntityManagersNode()
+    {
+        $treeBuilder = new TreeBuilder('entity_managers');
+
+        if (method_exists($treeBuilder, 'getRootNode')) {
+            $node = $treeBuilder->getRootNode();
+        } else {
+            // BC layer for symfony/config 4.1 and older
+            $node = $treeBuilder->root('entity_managers');
+        }
+
+        $node
+            ->requiresAtLeastOneElement()
+            ->useAttributeAsKey('name')
+            ->prototype('array')
+                ->addDefaultsIfNotSet()
+                ->append($this->getOrmCacheDriverNode('query_cache_driver'))
+                ->append($this->getOrmCacheDriverNode('metadata_cache_driver'))
+                ->append($this->getOrmCacheDriverNode('result_cache_driver'))
+                ->append($this->getOrmEntityListenersNode())
+                ->children()
+                    ->scalarNode('connection')->end()
+                    ->scalarNode('class_metadata_factory_name')->defaultValue('Doctrine\ORM\Mapping\ClassMetadataFactory')->end()
+                    ->scalarNode('default_repository_class')->defaultValue('Doctrine\ORM\EntityRepository')->end()
+                    ->scalarNode('auto_mapping')->defaultFalse()->end()
+                    ->scalarNode('naming_strategy')->defaultValue('doctrine.orm.naming_strategy.default')->end()
+                    ->scalarNode('quote_strategy')->defaultValue('doctrine.orm.quote_strategy.default')->end()
+                    ->scalarNode('entity_listener_resolver')->defaultNull()->end()
+                    ->scalarNode('repository_factory')->defaultValue('doctrine.orm.container_repository_factory')->end()
+                ->end()
+                ->children()
+                    ->arrayNode('second_level_cache')
+                        ->children()
+                            ->append($this->getOrmCacheDriverNode('region_cache_driver'))
+                            ->scalarNode('region_lock_lifetime')->defaultValue(60)->end()
+                            ->booleanNode('log_enabled')->defaultValue($this->debug)->end()
+                            ->scalarNode('region_lifetime')->defaultValue(0)->end()
+                            ->booleanNode('enabled')->defaultValue(true)->end()
+                            ->scalarNode('factory')->end()
+                        ->end()
+                        ->fixXmlConfig('region')
+                        ->children()
+                            ->arrayNode('regions')
+                                ->useAttributeAsKey('name')
+                                ->prototype('array')
+                                    ->children()
+                                        ->append($this->getOrmCacheDriverNode('cache_driver'))
+                                        ->scalarNode('lock_path')->defaultValue('%kernel.cache_dir%/doctrine/orm/slc/filelock')->end()
+                                        ->scalarNode('lock_lifetime')->defaultValue(60)->end()
+                                        ->scalarNode('type')->defaultValue('default')->end()
+                                        ->scalarNode('lifetime')->defaultValue(0)->end()
+                                        ->scalarNode('service')->end()
+                                        ->scalarNode('name')->end()
+                                    ->end()
+                                ->end()
+                            ->end()
+                        ->end()
+                        ->fixXmlConfig('logger')
+                        ->children()
+                            ->arrayNode('loggers')
+                                ->useAttributeAsKey('name')
+                                ->prototype('array')
+                                    ->children()
+                                        ->scalarNode('name')->end()
+                                        ->scalarNode('service')->end()
+                                    ->end()
+                                ->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                ->end()
+                ->fixXmlConfig('hydrator')
+                ->children()
+                    ->arrayNode('hydrators')
+                        ->useAttributeAsKey('name')
+                        ->prototype('scalar')->end()
+                    ->end()
+                ->end()
+                ->fixXmlConfig('mapping')
+                ->children()
+                    ->arrayNode('mappings')
+                        ->useAttributeAsKey('name')
+                        ->prototype('array')
+                            ->beforeNormalization()
+                                ->ifString()
+                                ->then(static function ($v) {
+                                    return ['type' => $v];
+                                })
+                            ->end()
+                            ->treatNullLike([])
+                            ->treatFalseLike(['mapping' => false])
+                            ->performNoDeepMerging()
+                            ->children()
+                                ->scalarNode('mapping')->defaultValue(true)->end()
+                                ->scalarNode('type')->end()
+                                ->scalarNode('dir')->end()
+                                ->scalarNode('alias')->end()
+                                ->scalarNode('prefix')->end()
+                                ->booleanNode('is_bundle')->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                    ->arrayNode('dql')
+                        ->fixXmlConfig('string_function')
+                        ->fixXmlConfig('numeric_function')
+                        ->fixXmlConfig('datetime_function')
+                        ->children()
+                            ->arrayNode('string_functions')
+                                ->useAttributeAsKey('name')
+                                ->prototype('scalar')->end()
+                            ->end()
+                            ->arrayNode('numeric_functions')
+                                ->useAttributeAsKey('name')
+                                ->prototype('scalar')->end()
+                            ->end()
+                            ->arrayNode('datetime_functions')
+                                ->useAttributeAsKey('name')
+                                ->prototype('scalar')->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                ->end()
+                ->fixXmlConfig('filter')
+                ->children()
+                    ->arrayNode('filters')
+                        ->info('Register SQL Filters in the entity manager')
+                        ->useAttributeAsKey('name')
+                        ->prototype('array')
+                            ->beforeNormalization()
+                                ->ifString()
+                                ->then(static function ($v) {
+                                    return ['class' => $v];
+                                })
+                            ->end()
+                            ->beforeNormalization()
+                                // The content of the XML node is returned as the "value" key so we need to rename it
+                                ->ifTrue(static function ($v) {
+                                    return is_array($v) && isset($v['value']);
+                                })
+                                ->then(static function ($v) {
+                                    $v['class'] = $v['value'];
+                                    unset($v['value']);
+
+                                    return $v;
+                                })
+                            ->end()
+                            ->fixXmlConfig('parameter')
+                            ->children()
+                                ->scalarNode('class')->isRequired()->end()
+                                ->booleanNode('enabled')->defaultFalse()->end()
+                                ->arrayNode('parameters')
+                                    ->useAttributeAsKey('name')
+                                    ->prototype('variable')->end()
+                                ->end()
+                            ->end()
+                        ->end()
+                    ->end()
+                ->end()
+            ->end();
+
+        return $node;
+    }
+
+    /**
+     * Return a ORM cache driver node for an given entity manager
+     *
+     * @param string $name
+     *
+     * @return ArrayNodeDefinition
+     */
+    private function getOrmCacheDriverNode($name)
+    {
+        $treeBuilder = new TreeBuilder($name);
+
+        if (method_exists($treeBuilder, 'getRootNode')) {
+            $node = $treeBuilder->getRootNode();
+        } else {
+            // BC layer for symfony/config 4.1 and older
+            $node = $treeBuilder->root($name);
+        }
+
+        $node
+            ->addDefaultsIfNotSet()
+            ->beforeNormalization()
+                ->ifString()
+                ->then(static function ($v) {
+                    return ['type' => $v];
+                })
+            ->end()
+            ->children()
+                ->scalarNode('type')->defaultValue('array')->end()
+                ->scalarNode('host')->end()
+                ->scalarNode('port')->end()
+                ->scalarNode('database')->end()
+                ->scalarNode('instance_class')->end()
+                ->scalarNode('class')->end()
+                ->scalarNode('id')->end()
+                ->scalarNode('namespace')->defaultNull()->end()
+                ->scalarNode('cache_provider')->defaultNull()->end()
+            ->end();
+
+        return $node;
+    }
+
+    /**
+     * Find proxy auto generate modes for their names and int values
+     *
+     * @return array
+     */
+    private function getAutoGenerateModes()
+    {
+        $constPrefix = 'AUTOGENERATE_';
+        $prefixLen   = strlen($constPrefix);
+        $refClass    = new ReflectionClass('Doctrine\Common\Proxy\AbstractProxyFactory');
+        $constsArray = $refClass->getConstants();
+        $namesArray  = [];
+        $valuesArray = [];
+
+        foreach ($constsArray as $key => $value) {
+            if (strpos($key, $constPrefix) !== 0) {
+                continue;
+            }
+
+            $namesArray[]  = substr($key, $prefixLen);
+            $valuesArray[] = (int) $value;
+        }
+
+        return [
+            'names' => $namesArray,
+            'values' => $valuesArray,
+        ];
+    }
+}

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

@@ -0,0 +1,861 @@
+<?php
+
+namespace Doctrine\Bundle\DoctrineBundle\DependencyInjection;
+
+use Doctrine\Bundle\DoctrineBundle\DependencyInjection\Compiler\ServiceRepositoryCompilerPass;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepositoryInterface;
+use Doctrine\Bundle\DoctrineCacheBundle\DependencyInjection\CacheProviderLoader;
+use Doctrine\Bundle\DoctrineCacheBundle\DependencyInjection\SymfonyBridgeAdapter;
+use Doctrine\Common\Persistence\Mapping\ClassMetadataFactory;
+use Doctrine\ORM\Version;
+use LogicException;
+use Symfony\Bridge\Doctrine\DependencyInjection\AbstractDoctrineExtension;
+use Symfony\Bridge\Doctrine\Form\Type\DoctrineType;
+use Symfony\Bridge\Doctrine\Messenger\DoctrineTransactionMiddleware;
+use Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor;
+use Symfony\Component\Config\FileLocator;
+use Symfony\Component\DependencyInjection\Alias;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\DefinitionDecorator;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\ServiceLocator;
+use Symfony\Component\Form\AbstractType;
+use Symfony\Component\Messenger\MessageBusInterface;
+
+/**
+ * DoctrineExtension is an extension for the Doctrine DBAL and ORM library.
+ */
+class DoctrineExtension extends AbstractDoctrineExtension
+{
+    /** @var string */
+    private $defaultConnection;
+
+    /** @var SymfonyBridgeAdapter */
+    private $adapter;
+
+    public function __construct(SymfonyBridgeAdapter $adapter = null)
+    {
+        $this->adapter = $adapter ?: new SymfonyBridgeAdapter(new CacheProviderLoader(), 'doctrine.orm', 'orm');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function load(array $configs, ContainerBuilder $container)
+    {
+        $configuration = $this->getConfiguration($configs, $container);
+        $config        = $this->processConfiguration($configuration, $configs);
+
+        $this->adapter->loadServicesConfiguration($container);
+
+        if (! empty($config['dbal'])) {
+            $this->dbalLoad($config['dbal'], $container);
+        }
+
+        if (empty($config['orm'])) {
+            return;
+        }
+
+        if (empty($config['dbal'])) {
+            throw new LogicException('Configuring the ORM layer requires to configure the DBAL layer as well.');
+        }
+
+        if (! class_exists('Doctrine\ORM\Version')) {
+            throw new LogicException('To configure the ORM layer, you must first install the doctrine/orm package.');
+        }
+
+        $this->ormLoad($config['orm'], $container);
+    }
+
+    /**
+     * Loads the DBAL configuration.
+     *
+     * Usage example:
+     *
+     *      <doctrine:dbal id="myconn" dbname="sfweb" user="root" />
+     *
+     * @param array            $config    An array of configuration settings
+     * @param ContainerBuilder $container A ContainerBuilder instance
+     */
+    protected function dbalLoad(array $config, ContainerBuilder $container)
+    {
+        $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
+        $loader->load('dbal.xml');
+
+        if (empty($config['default_connection'])) {
+            $keys                         = array_keys($config['connections']);
+            $config['default_connection'] = reset($keys);
+        }
+
+        $this->defaultConnection = $config['default_connection'];
+
+        $container->setAlias('database_connection', sprintf('doctrine.dbal.%s_connection', $this->defaultConnection));
+        $container->getAlias('database_connection')->setPublic(true);
+        $container->setAlias('doctrine.dbal.event_manager', new Alias(sprintf('doctrine.dbal.%s_connection.event_manager', $this->defaultConnection), false));
+
+        $container->setParameter('doctrine.dbal.connection_factory.types', $config['types']);
+
+        $connections = [];
+
+        foreach (array_keys($config['connections']) as $name) {
+            $connections[$name] = sprintf('doctrine.dbal.%s_connection', $name);
+        }
+
+        $container->setParameter('doctrine.connections', $connections);
+        $container->setParameter('doctrine.default_connection', $this->defaultConnection);
+
+        foreach ($config['connections'] as $name => $connection) {
+            $this->loadDbalConnection($name, $connection, $container);
+        }
+    }
+
+    /**
+     * Loads a configured DBAL connection.
+     *
+     * @param string           $name       The name of the connection
+     * @param array            $connection A dbal connection configuration.
+     * @param ContainerBuilder $container  A ContainerBuilder instance
+     */
+    protected function loadDbalConnection($name, array $connection, ContainerBuilder $container)
+    {
+        // configuration
+        $definitionClassname = $this->getDefinitionClassname();
+
+        $configuration = $container->setDefinition(sprintf('doctrine.dbal.%s_connection.configuration', $name), new $definitionClassname('doctrine.dbal.connection.configuration'));
+        $logger        = null;
+        if ($connection['logging']) {
+            $logger = new Reference('doctrine.dbal.logger');
+        }
+        unset($connection['logging']);
+        if ($connection['profiling']) {
+            $profilingLoggerId = 'doctrine.dbal.logger.profiling.' . $name;
+            $container->setDefinition($profilingLoggerId, new $definitionClassname('doctrine.dbal.logger.profiling'));
+            $profilingLogger = new Reference($profilingLoggerId);
+            $container->getDefinition('data_collector.doctrine')->addMethodCall('addLogger', [$name, $profilingLogger]);
+
+            if ($logger !== null) {
+                $chainLogger = new $definitionClassname('doctrine.dbal.logger.chain');
+                $chainLogger->addMethodCall('addLogger', [$profilingLogger]);
+
+                $loggerId = 'doctrine.dbal.logger.chain.' . $name;
+                $container->setDefinition($loggerId, $chainLogger);
+                $logger = new Reference($loggerId);
+            } else {
+                $logger = $profilingLogger;
+            }
+        }
+        unset($connection['profiling']);
+
+        if (isset($connection['auto_commit'])) {
+            $configuration->addMethodCall('setAutoCommit', [$connection['auto_commit']]);
+        }
+
+        unset($connection['auto_commit']);
+
+        if (isset($connection['schema_filter']) && $connection['schema_filter']) {
+            $configuration->addMethodCall('setFilterSchemaAssetsExpression', [$connection['schema_filter']]);
+        }
+
+        unset($connection['schema_filter']);
+
+        if ($logger) {
+            $configuration->addMethodCall('setSQLLogger', [$logger]);
+        }
+
+        // event manager
+        $container->setDefinition(sprintf('doctrine.dbal.%s_connection.event_manager', $name), new $definitionClassname('doctrine.dbal.connection.event_manager'));
+
+        // connection
+        $options = $this->getConnectionOptions($connection);
+
+        $def = $container
+            ->setDefinition(sprintf('doctrine.dbal.%s_connection', $name), new $definitionClassname('doctrine.dbal.connection'))
+            ->setPublic(true)
+            ->setArguments([
+                $options,
+                new Reference(sprintf('doctrine.dbal.%s_connection.configuration', $name)),
+                new Reference(sprintf('doctrine.dbal.%s_connection.event_manager', $name)),
+                $connection['mapping_types'],
+            ]);
+
+        // Set class in case "wrapper_class" option was used to assist IDEs
+        if (isset($options['wrapperClass'])) {
+            $def->setClass($options['wrapperClass']);
+        }
+
+        if (! empty($connection['use_savepoints'])) {
+            $def->addMethodCall('setNestTransactionsWithSavepoints', [$connection['use_savepoints']]);
+        }
+
+        // Create a shard_manager for this connection
+        if (! isset($options['shards'])) {
+            return;
+        }
+
+        $shardManagerDefinition = new Definition($options['shardManagerClass'], [new Reference(sprintf('doctrine.dbal.%s_connection', $name))]);
+        $container->setDefinition(sprintf('doctrine.dbal.%s_shard_manager', $name), $shardManagerDefinition);
+    }
+
+    protected function getConnectionOptions($connection)
+    {
+        $options = $connection;
+
+        if (isset($options['platform_service'])) {
+            $options['platform'] = new Reference($options['platform_service']);
+            unset($options['platform_service']);
+        }
+        unset($options['mapping_types']);
+
+        if (isset($options['shard_choser_service'])) {
+            $options['shard_choser'] = new Reference($options['shard_choser_service']);
+            unset($options['shard_choser_service']);
+        }
+
+        foreach ([
+            'options' => 'driverOptions',
+            'driver_class' => 'driverClass',
+            'wrapper_class' => 'wrapperClass',
+            'keep_slave' => 'keepSlave',
+            'shard_choser' => 'shardChoser',
+            'shard_manager_class' => 'shardManagerClass',
+            'server_version' => 'serverVersion',
+            'default_table_options' => 'defaultTableOptions',
+        ] as $old => $new) {
+            if (! isset($options[$old])) {
+                continue;
+            }
+
+            $options[$new] = $options[$old];
+            unset($options[$old]);
+        }
+
+        if (! empty($options['slaves']) && ! empty($options['shards'])) {
+            throw new InvalidArgumentException('Sharding and master-slave connection cannot be used together');
+        }
+
+        if (! empty($options['slaves'])) {
+            $nonRewrittenKeys = [
+                'driver' => true,
+                'driverOptions' => true,
+                'driverClass' => true,
+                'wrapperClass' => true,
+                'keepSlave' => true,
+                'shardChoser' => true,
+                'platform' => true,
+                'slaves' => true,
+                'master' => true,
+                'shards' => true,
+                'serverVersion' => true,
+                'defaultTableOptions' => true,
+                // included by safety but should have been unset already
+                'logging' => true,
+                'profiling' => true,
+                'mapping_types' => true,
+                'platform_service' => true,
+            ];
+            foreach ($options as $key => $value) {
+                if (isset($nonRewrittenKeys[$key])) {
+                    continue;
+                }
+                $options['master'][$key] = $value;
+                unset($options[$key]);
+            }
+            if (empty($options['wrapperClass'])) {
+                // Change the wrapper class only if the user does not already forced using a custom one.
+                $options['wrapperClass'] = 'Doctrine\\DBAL\\Connections\\MasterSlaveConnection';
+            }
+        } else {
+            unset($options['slaves']);
+        }
+
+        if (! empty($options['shards'])) {
+            $nonRewrittenKeys = [
+                'driver' => true,
+                'driverOptions' => true,
+                'driverClass' => true,
+                'wrapperClass' => true,
+                'keepSlave' => true,
+                'shardChoser' => true,
+                'platform' => true,
+                'slaves' => true,
+                'global' => true,
+                'shards' => true,
+                'serverVersion' => true,
+                'defaultTableOptions' => true,
+                // included by safety but should have been unset already
+                'logging' => true,
+                'profiling' => true,
+                'mapping_types' => true,
+                'platform_service' => true,
+            ];
+            foreach ($options as $key => $value) {
+                if (isset($nonRewrittenKeys[$key])) {
+                    continue;
+                }
+                $options['global'][$key] = $value;
+                unset($options[$key]);
+            }
+            if (empty($options['wrapperClass'])) {
+                // Change the wrapper class only if the user does not already forced using a custom one.
+                $options['wrapperClass'] = 'Doctrine\\DBAL\\Sharding\\PoolingShardConnection';
+            }
+            if (empty($options['shardManagerClass'])) {
+                // Change the shard manager class only if the user does not already forced using a custom one.
+                $options['shardManagerClass'] = 'Doctrine\\DBAL\\Sharding\\PoolingShardManager';
+            }
+        } else {
+            unset($options['shards']);
+        }
+
+        return $options;
+    }
+
+    /**
+     * Loads the Doctrine ORM configuration.
+     *
+     * Usage example:
+     *
+     *     <doctrine:orm id="mydm" connection="myconn" />
+     *
+     * @param array            $config    An array of configuration settings
+     * @param ContainerBuilder $container A ContainerBuilder instance
+     */
+    protected function ormLoad(array $config, ContainerBuilder $container)
+    {
+        $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
+        $loader->load('orm.xml');
+
+        if (class_exists(AbstractType::class) && method_exists(DoctrineType::class, 'reset')) {
+            $container->getDefinition('form.type.entity')->addTag('kernel.reset', ['method' => 'reset']);
+        }
+
+        $entityManagers = [];
+        foreach (array_keys($config['entity_managers']) as $name) {
+            $entityManagers[$name] = sprintf('doctrine.orm.%s_entity_manager', $name);
+        }
+        $container->setParameter('doctrine.entity_managers', $entityManagers);
+
+        if (empty($config['default_entity_manager'])) {
+            $tmp                              = array_keys($entityManagers);
+            $config['default_entity_manager'] = reset($tmp);
+        }
+        $container->setParameter('doctrine.default_entity_manager', $config['default_entity_manager']);
+
+        $options = ['auto_generate_proxy_classes', 'proxy_dir', 'proxy_namespace'];
+        foreach ($options as $key) {
+            $container->setParameter('doctrine.orm.' . $key, $config[$key]);
+        }
+
+        $container->setAlias('doctrine.orm.entity_manager', sprintf('doctrine.orm.%s_entity_manager', $config['default_entity_manager']));
+        $container->getAlias('doctrine.orm.entity_manager')->setPublic(true);
+
+        $config['entity_managers'] = $this->fixManagersAutoMappings($config['entity_managers'], $container->getParameter('kernel.bundles'));
+
+        $loadPropertyInfoExtractor = interface_exists('Symfony\Component\PropertyInfo\PropertyInfoExtractorInterface')
+            && class_exists('Symfony\Bridge\Doctrine\PropertyInfo\DoctrineExtractor');
+
+        foreach ($config['entity_managers'] as $name => $entityManager) {
+            $entityManager['name'] = $name;
+            $this->loadOrmEntityManager($entityManager, $container);
+
+            if (! $loadPropertyInfoExtractor) {
+                continue;
+            }
+
+            $this->loadPropertyInfoExtractor($name, $container);
+        }
+
+        if ($config['resolve_target_entities']) {
+            $def = $container->findDefinition('doctrine.orm.listeners.resolve_target_entity');
+            foreach ($config['resolve_target_entities'] as $name => $implementation) {
+                $def->addMethodCall('addResolveTargetEntity', [
+                    $name,
+                    $implementation,
+                    [],
+                ]);
+            }
+
+            // BC: ResolveTargetEntityListener implements the subscriber interface since
+            // v2.5.0-beta1 (Commit 437f812)
+            if (version_compare(Version::VERSION, '2.5.0-DEV') < 0) {
+                $def->addTag('doctrine.event_listener', ['event' => 'loadClassMetadata']);
+            } else {
+                $def->addTag('doctrine.event_subscriber');
+            }
+        }
+
+        // if is for Symfony 3.2 and lower compat
+        if (method_exists($container, 'registerForAutoconfiguration')) {
+            $container->registerForAutoconfiguration(ServiceEntityRepositoryInterface::class)
+                ->addTag(ServiceRepositoryCompilerPass::REPOSITORY_SERVICE_TAG);
+        }
+
+        // If the Messenger component is installed and the doctrine transaction middleware is available, wire it:
+        if (interface_exists(MessageBusInterface::class) && class_exists(DoctrineTransactionMiddleware::class)) {
+            $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
+            $loader->load('messenger.xml');
+        }
+
+        /*
+         * Compatibility for Symfony 3.2 and lower: gives the service a default argument.
+         * When DoctrineBundle requires 3.3 or higher, this can be moved to an anonymous
+         * service in orm.xml.
+         *
+         * This is replaced with a true locator by ServiceRepositoryCompilerPass.
+         * This makes that pass technically optional (good for tests).
+         */
+        if (! class_exists(ServiceLocator::class)) {
+            return;
+        }
+
+        $container->getDefinition('doctrine.orm.container_repository_factory')
+            ->replaceArgument(0, (new Definition(ServiceLocator::class))->setArgument(0, []));
+    }
+
+    /**
+     * Loads a configured ORM entity manager.
+     *
+     * @param array            $entityManager A configured ORM entity manager.
+     * @param ContainerBuilder $container     A ContainerBuilder instance
+     */
+    protected function loadOrmEntityManager(array $entityManager, ContainerBuilder $container)
+    {
+        $definitionClassname = $this->getDefinitionClassname();
+        $ormConfigDef        = $container->setDefinition(sprintf('doctrine.orm.%s_configuration', $entityManager['name']), new $definitionClassname('doctrine.orm.configuration'));
+
+        $this->loadOrmEntityManagerMappingInformation($entityManager, $ormConfigDef, $container);
+        $this->loadOrmCacheDrivers($entityManager, $container);
+
+        if (isset($entityManager['entity_listener_resolver']) && $entityManager['entity_listener_resolver']) {
+            $container->setAlias(sprintf('doctrine.orm.%s_entity_listener_resolver', $entityManager['name']), $entityManager['entity_listener_resolver']);
+        } else {
+            $definition = new Definition('%doctrine.orm.entity_listener_resolver.class%');
+            $definition->addArgument(new Reference('service_container'));
+            $container->setDefinition(sprintf('doctrine.orm.%s_entity_listener_resolver', $entityManager['name']), $definition);
+        }
+
+        $methods = [
+            'setMetadataCacheImpl' => new Reference(sprintf('doctrine.orm.%s_metadata_cache', $entityManager['name'])),
+            'setQueryCacheImpl' => new Reference(sprintf('doctrine.orm.%s_query_cache', $entityManager['name'])),
+            'setResultCacheImpl' => new Reference(sprintf('doctrine.orm.%s_result_cache', $entityManager['name'])),
+            'setMetadataDriverImpl' => new Reference('doctrine.orm.' . $entityManager['name'] . '_metadata_driver'),
+            'setProxyDir' => '%doctrine.orm.proxy_dir%',
+            'setProxyNamespace' => '%doctrine.orm.proxy_namespace%',
+            'setAutoGenerateProxyClasses' => '%doctrine.orm.auto_generate_proxy_classes%',
+            'setClassMetadataFactoryName' => $entityManager['class_metadata_factory_name'],
+            'setDefaultRepositoryClassName' => $entityManager['default_repository_class'],
+        ];
+        // check for version to keep BC
+        if (version_compare(Version::VERSION, '2.3.0-DEV') >= 0) {
+            $methods = array_merge($methods, [
+                'setNamingStrategy' => new Reference($entityManager['naming_strategy']),
+                'setQuoteStrategy' => new Reference($entityManager['quote_strategy']),
+            ]);
+        }
+
+        if (version_compare(Version::VERSION, '2.4.0-DEV') >= 0) {
+            $methods = array_merge($methods, [
+                'setEntityListenerResolver' => new Reference(sprintf('doctrine.orm.%s_entity_listener_resolver', $entityManager['name'])),
+            ]);
+        }
+
+        if (version_compare(Version::VERSION, '2.5.0-DEV') >= 0) {
+            $listenerId        = sprintf('doctrine.orm.%s_listeners.attach_entity_listeners', $entityManager['name']);
+            $listenerDef       = $container->setDefinition($listenerId, new Definition('%doctrine.orm.listeners.attach_entity_listeners.class%'));
+            $listenerTagParams = ['event' => 'loadClassMetadata'];
+            if (isset($entityManager['connection'])) {
+                $listenerTagParams['connection'] = $entityManager['connection'];
+            }
+            $listenerDef->addTag('doctrine.event_listener', $listenerTagParams);
+        }
+
+        if (isset($entityManager['second_level_cache'])) {
+            $this->loadOrmSecondLevelCache($entityManager, $ormConfigDef, $container);
+        }
+
+        if ($entityManager['repository_factory']) {
+            $methods['setRepositoryFactory'] = new Reference($entityManager['repository_factory']);
+        }
+
+        foreach ($methods as $method => $arg) {
+            $ormConfigDef->addMethodCall($method, [$arg]);
+        }
+
+        foreach ($entityManager['hydrators'] as $name => $class) {
+            $ormConfigDef->addMethodCall('addCustomHydrationMode', [$name, $class]);
+        }
+
+        if (! empty($entityManager['dql'])) {
+            foreach ($entityManager['dql']['string_functions'] as $name => $function) {
+                $ormConfigDef->addMethodCall('addCustomStringFunction', [$name, $function]);
+            }
+            foreach ($entityManager['dql']['numeric_functions'] as $name => $function) {
+                $ormConfigDef->addMethodCall('addCustomNumericFunction', [$name, $function]);
+            }
+            foreach ($entityManager['dql']['datetime_functions'] as $name => $function) {
+                $ormConfigDef->addMethodCall('addCustomDatetimeFunction', [$name, $function]);
+            }
+        }
+
+        $enabledFilters    = [];
+        $filtersParameters = [];
+        foreach ($entityManager['filters'] as $name => $filter) {
+            $ormConfigDef->addMethodCall('addFilter', [$name, $filter['class']]);
+            if ($filter['enabled']) {
+                $enabledFilters[] = $name;
+            }
+            if (! $filter['parameters']) {
+                continue;
+            }
+
+            $filtersParameters[$name] = $filter['parameters'];
+        }
+
+        $managerConfiguratorName = sprintf('doctrine.orm.%s_manager_configurator', $entityManager['name']);
+        $container
+            ->setDefinition($managerConfiguratorName, new $definitionClassname('doctrine.orm.manager_configurator.abstract'))
+            ->replaceArgument(0, $enabledFilters)
+            ->replaceArgument(1, $filtersParameters);
+
+        if (! isset($entityManager['connection'])) {
+            $entityManager['connection'] = $this->defaultConnection;
+        }
+
+        $container
+            ->setDefinition(sprintf('doctrine.orm.%s_entity_manager', $entityManager['name']), new $definitionClassname('doctrine.orm.entity_manager.abstract'))
+            ->setPublic(true)
+            ->setArguments([
+                new Reference(sprintf('doctrine.dbal.%s_connection', $entityManager['connection'])),
+                new Reference(sprintf('doctrine.orm.%s_configuration', $entityManager['name'])),
+            ])
+            ->setConfigurator([new Reference($managerConfiguratorName), 'configure']);
+
+        $container->setAlias(
+            sprintf('doctrine.orm.%s_entity_manager.event_manager', $entityManager['name']),
+            new Alias(sprintf('doctrine.dbal.%s_connection.event_manager', $entityManager['connection']), false)
+        );
+
+        if (! isset($entityManager['entity_listeners'])) {
+            return;
+        }
+
+        if (! isset($listenerDef)) {
+            throw new InvalidArgumentException('Entity listeners configuration requires doctrine-orm 2.5.0 or newer');
+        }
+
+        $entities = $entityManager['entity_listeners']['entities'];
+
+        foreach ($entities as $entityListenerClass => $entity) {
+            foreach ($entity['listeners'] as $listenerClass => $listener) {
+                foreach ($listener['events'] as $listenerEvent) {
+                    $listenerEventName = $listenerEvent['type'];
+                    $listenerMethod    = $listenerEvent['method'];
+
+                    $listenerDef->addMethodCall('addEntityListener', [
+                        $entityListenerClass,
+                        $listenerClass,
+                        $listenerEventName,
+                        $listenerMethod,
+                    ]);
+                }
+            }
+        }
+    }
+
+    /**
+     * Loads an ORM entity managers bundle mapping information.
+     *
+     * There are two distinct configuration possibilities for mapping information:
+     *
+     * 1. Specify a bundle and optionally details where the entity and mapping information reside.
+     * 2. Specify an arbitrary mapping location.
+     *
+     * @param array            $entityManager A configured ORM entity manager
+     * @param Definition       $ormConfigDef  A Definition instance
+     * @param ContainerBuilder $container     A ContainerBuilder instance
+     *
+     * @example
+     *
+     *  doctrine.orm:
+     *     mappings:
+     *         MyBundle1: ~
+     *         MyBundle2: yml
+     *         MyBundle3: { type: annotation, dir: Entities/ }
+     *         MyBundle4: { type: xml, dir: Resources/config/doctrine/mapping }
+     *         MyBundle5:
+     *             type: yml
+     *             dir: bundle-mappings/
+     *             alias: BundleAlias
+     *         arbitrary_key:
+     *             type: xml
+     *             dir: %kernel.root_dir%/../src/vendor/DoctrineExtensions/lib/DoctrineExtensions/Entities
+     *             prefix: DoctrineExtensions\Entities\
+     *             alias: DExt
+     *
+     * In the case of bundles everything is really optional (which leads to autodetection for this bundle) but
+     * in the mappings key everything except alias is a required argument.
+     */
+    protected function loadOrmEntityManagerMappingInformation(array $entityManager, Definition $ormConfigDef, ContainerBuilder $container)
+    {
+        // reset state of drivers and alias map. They are only used by this methods and children.
+        $this->drivers  = [];
+        $this->aliasMap = [];
+
+        $this->loadMappingInformation($entityManager, $container);
+        $this->registerMappingDrivers($entityManager, $container);
+
+        $ormConfigDef->addMethodCall('setEntityNamespaces', [$this->aliasMap]);
+    }
+
+    /**
+     * Loads an ORM second level cache bundle mapping information.
+     *
+     * @param array            $entityManager A configured ORM entity manager
+     * @param Definition       $ormConfigDef  A Definition instance
+     * @param ContainerBuilder $container     A ContainerBuilder instance
+     *
+     * @example
+     *  entity_managers:
+     *      default:
+     *          second_level_cache:
+     *              region_cache_driver: apc
+     *              log_enabled: true
+     *              regions:
+     *                  my_service_region:
+     *                      type: service
+     *                      service : "my_service_region"
+     *
+     *                  my_query_region:
+     *                      lifetime: 300
+     *                      cache_driver: array
+     *                      type: filelock
+     *
+     *                  my_entity_region:
+     *                      lifetime: 600
+     *                      cache_driver:
+     *                          type: apc
+     */
+    protected function loadOrmSecondLevelCache(array $entityManager, Definition $ormConfigDef, ContainerBuilder $container)
+    {
+        if (version_compare(Version::VERSION, '2.5.0-DEV') < 0) {
+            throw new \InvalidArgumentException('Second-level cache requires doctrine-orm 2.5.0 or newer');
+        }
+
+        $driverId = null;
+        $enabled  = $entityManager['second_level_cache']['enabled'];
+
+        if (isset($entityManager['second_level_cache']['region_cache_driver'])) {
+            $driverName = 'second_level_cache.region_cache_driver';
+            $driverMap  = $entityManager['second_level_cache']['region_cache_driver'];
+            $driverId   = $this->loadCacheDriver($driverName, $entityManager['name'], $driverMap, $container);
+        }
+
+        $configId   = sprintf('doctrine.orm.%s_second_level_cache.cache_configuration', $entityManager['name']);
+        $regionsId  = sprintf('doctrine.orm.%s_second_level_cache.regions_configuration', $entityManager['name']);
+        $driverId   = $driverId ?: sprintf('doctrine.orm.%s_second_level_cache.region_cache_driver', $entityManager['name']);
+        $configDef  = $container->setDefinition($configId, new Definition('%doctrine.orm.second_level_cache.cache_configuration.class%'));
+        $regionsDef = $container->setDefinition($regionsId, new Definition('%doctrine.orm.second_level_cache.regions_configuration.class%'));
+
+        $slcFactoryId = sprintf('doctrine.orm.%s_second_level_cache.default_cache_factory', $entityManager['name']);
+        $factoryClass = isset($entityManager['second_level_cache']['factory']) ? $entityManager['second_level_cache']['factory'] : '%doctrine.orm.second_level_cache.default_cache_factory.class%';
+
+        $definition = new Definition($factoryClass, [new Reference($regionsId), new Reference($driverId)]);
+
+        $slcFactoryDef = $container
+            ->setDefinition($slcFactoryId, $definition);
+
+        if (isset($entityManager['second_level_cache']['regions'])) {
+            foreach ($entityManager['second_level_cache']['regions'] as $name => $region) {
+                $regionRef  = null;
+                $regionType = $region['type'];
+
+                if ($regionType === 'service') {
+                    $regionId  = sprintf('doctrine.orm.%s_second_level_cache.region.%s', $entityManager['name'], $name);
+                    $regionRef = new Reference($region['service']);
+
+                    $container->setAlias($regionId, new Alias($region['service'], false));
+                }
+
+                if ($regionType === 'default' || $regionType === 'filelock') {
+                    $regionId   = sprintf('doctrine.orm.%s_second_level_cache.region.%s', $entityManager['name'], $name);
+                    $driverName = sprintf('second_level_cache.region.%s_driver', $name);
+                    $driverMap  = $region['cache_driver'];
+                    $driverId   = $this->loadCacheDriver($driverName, $entityManager['name'], $driverMap, $container);
+                    $regionRef  = new Reference($regionId);
+
+                    $container
+                        ->setDefinition($regionId, new Definition('%doctrine.orm.second_level_cache.default_region.class%'))
+                        ->setArguments([$name, new Reference($driverId), $region['lifetime']]);
+                }
+
+                if ($regionType === 'filelock') {
+                    $regionId = sprintf('doctrine.orm.%s_second_level_cache.region.%s_filelock', $entityManager['name'], $name);
+
+                    $container
+                        ->setDefinition($regionId, new Definition('%doctrine.orm.second_level_cache.filelock_region.class%'))
+                        ->setArguments([$regionRef, $region['lock_path'], $region['lock_lifetime']]);
+
+                    $regionRef = new Reference($regionId);
+                    $regionsDef->addMethodCall('getLockLifetime', [$name, $region['lock_lifetime']]);
+                }
+
+                $regionsDef->addMethodCall('setLifetime', [$name, $region['lifetime']]);
+                $slcFactoryDef->addMethodCall('setRegion', [$regionRef]);
+            }
+        }
+
+        if ($entityManager['second_level_cache']['log_enabled']) {
+            $loggerChainId   = sprintf('doctrine.orm.%s_second_level_cache.logger_chain', $entityManager['name']);
+            $loggerStatsId   = sprintf('doctrine.orm.%s_second_level_cache.logger_statistics', $entityManager['name']);
+            $loggerChaingDef = $container->setDefinition($loggerChainId, new Definition('%doctrine.orm.second_level_cache.logger_chain.class%'));
+            $loggerStatsDef  = $container->setDefinition($loggerStatsId, new Definition('%doctrine.orm.second_level_cache.logger_statistics.class%'));
+
+            $loggerChaingDef->addMethodCall('setLogger', ['statistics', $loggerStatsDef]);
+            $configDef->addMethodCall('setCacheLogger', [$loggerChaingDef]);
+
+            foreach ($entityManager['second_level_cache']['loggers'] as $name => $logger) {
+                $loggerId  = sprintf('doctrine.orm.%s_second_level_cache.logger.%s', $entityManager['name'], $name);
+                $loggerRef = new Reference($logger['service']);
+
+                $container->setAlias($loggerId, new Alias($logger['service'], false));
+                $loggerChaingDef->addMethodCall('setLogger', [$name, $loggerRef]);
+            }
+        }
+
+        $configDef->addMethodCall('setCacheFactory', [$slcFactoryDef]);
+        $configDef->addMethodCall('setRegionsConfiguration', [$regionsDef]);
+        $ormConfigDef->addMethodCall('setSecondLevelCacheEnabled', [$enabled]);
+        $ormConfigDef->addMethodCall('setSecondLevelCacheConfiguration', [$configDef]);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getObjectManagerElementName($name)
+    {
+        return 'doctrine.orm.' . $name;
+    }
+
+    protected function getMappingObjectDefaultName()
+    {
+        return 'Entity';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getMappingResourceConfigDirectory()
+    {
+        return 'Resources/config/doctrine';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getMappingResourceExtension()
+    {
+        return 'orm';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function loadCacheDriver($driverName, $entityManagerName, array $driverMap, ContainerBuilder $container)
+    {
+        if (! empty($driverMap['cache_provider'])) {
+            $aliasId   = $this->getObjectManagerElementName(sprintf('%s_%s', $entityManagerName, $driverName));
+            $serviceId = sprintf('doctrine_cache.providers.%s', $driverMap['cache_provider']);
+
+            $container->setAlias($aliasId, new Alias($serviceId, false));
+
+            return $aliasId;
+        }
+
+        return $this->adapter->loadCacheDriver($driverName, $entityManagerName, $driverMap, $container);
+    }
+
+    /**
+     * Loads a configured entity managers cache drivers.
+     *
+     * @param array            $entityManager A configured ORM entity manager.
+     * @param ContainerBuilder $container     A ContainerBuilder instance
+     */
+    protected function loadOrmCacheDrivers(array $entityManager, ContainerBuilder $container)
+    {
+        $this->loadCacheDriver('metadata_cache', $entityManager['name'], $entityManager['metadata_cache_driver'], $container);
+        $this->loadCacheDriver('result_cache', $entityManager['name'], $entityManager['result_cache_driver'], $container);
+        $this->loadCacheDriver('query_cache', $entityManager['name'], $entityManager['query_cache_driver'], $container);
+    }
+
+    /**
+     * Loads a property info extractor for each defined entity manager.
+     *
+     * @param string $entityManagerName
+     */
+    private function loadPropertyInfoExtractor($entityManagerName, ContainerBuilder $container)
+    {
+        $propertyExtractorDefinition = $container->register(sprintf('doctrine.orm.%s_entity_manager.property_info_extractor', $entityManagerName), DoctrineExtractor::class);
+        if (property_exists(DoctrineExtractor::class, 'entityManager')) {
+            $argumentId = sprintf('doctrine.orm.%s_entity_manager', $entityManagerName);
+        } else {
+            $argumentId = sprintf('doctrine.orm.%s_entity_manager.metadata_factory', $entityManagerName);
+
+            $metadataFactoryDefinition = $container->register($argumentId, ClassMetadataFactory::class);
+            $metadataFactoryDefinition->setFactory([
+                new Reference(sprintf('doctrine.orm.%s_entity_manager', $entityManagerName)),
+                'getMetadataFactory',
+            ]);
+            $metadataFactoryDefinition->setPublic(false);
+        }
+
+        $propertyExtractorDefinition->addArgument(new Reference($argumentId));
+
+        $propertyExtractorDefinition->addTag('property_info.list_extractor', ['priority' => -1001]);
+        $propertyExtractorDefinition->addTag('property_info.type_extractor', ['priority' => -999]);
+    }
+
+    /**
+     * @param array  $objectManager
+     * @param string $cacheName
+     */
+    public function loadObjectManagerCacheDriver(array $objectManager, ContainerBuilder $container, $cacheName)
+    {
+        $this->loadCacheDriver($cacheName, $objectManager['name'], $objectManager[$cacheName . '_driver'], $container);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getXsdValidationBasePath()
+    {
+        return __DIR__ . '/../Resources/config/schema';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getNamespace()
+    {
+        return 'http://symfony.com/schema/dic/doctrine';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getConfiguration(array $config, ContainerBuilder $container)
+    {
+        return new Configuration($container->getParameter('kernel.debug'));
+    }
+
+    /**
+     * @return string
+     */
+    private function getDefinitionClassname()
+    {
+        return class_exists(ChildDefinition::class) ? ChildDefinition::class : DefinitionDecorator::class;
+    }
+}