Chubbyphp\DoctrineDbServiceProvider\Factory\DoctrineDbalFactory

Complexity

Total Complexity

16

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

1 Method

Rating	Name	Duplication	Size	Complexity
D	__invoke()	0	184	16

<?php

declare(strict_types=1);

namespace Chubbyphp\DoctrineDbServiceProvider\Factory;

use Chubbyphp\Container\Container;
use Chubbyphp\Container\ContainerInterface;
use Chubbyphp\DoctrineDbServiceProvider\Logger\DoctrineDbalLogger;
use Chubbyphp\DoctrineDbServiceProvider\Registry\Psr\DoctrineDbalConnectionRegistry;
use Doctrine\Common\Cache\ApcuCache;
use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Cache\Cache;
use Doctrine\Common\EventManager;
use Doctrine\DBAL\Configuration;
use Doctrine\DBAL\DriverManager;
use Doctrine\DBAL\Types\Type;

final class DoctrineDbalFactory
{
    public function __invoke(): array
    {
        return [
            'doctrine.dbal.connection_registry' => static function (ContainerInterface $container) {
                return new DoctrineDbalConnectionRegistry($container);
            },
            'doctrine.dbal.db' => static function (ContainerInterface $container) {
                /** @var Container $dbs */
                $dbs = $container->get('doctrine.dbal.dbs');

                return $dbs->get($container->get('doctrine.dbal.dbs.default'));
            },
            'doctrine.dbal.db.cache_factory.apcu' => static function () {
                return static function () {
                    return new ApcuCache();
                };
            },
            'doctrine.dbal.db.cache_factory.array' => static function () {
                return static function () {
                    return new ArrayCache();
                };
            },
            'doctrine.dbal.db.config' => static function (ContainerInterface $container) {
                /** @var Container $dbsConfigs */
                $dbsConfigs = $container->get('doctrine.dbal.dbs.config');

                return $dbsConfigs->get($container->get('doctrine.dbal.dbs.default'));
            },
            'doctrine.dbal.db.default_options' => static function () {
                return [
                    'configuration' => [
                        'auto_commit' => true,
                        'cache.result' => ['type' => 'array'],
                        'filter_schema_assets_expression' => null, // @deprecated
                        'schema_assets_filter' => null,
                    ],
                    'connection' => [
                        'charset' => 'utf8mb4',
                        'dbname' => null,
                        'driver' => 'pdo_mysql',
                        'host' => 'localhost',
                        'password' => null,
                        'path' => null,
                        'port' => 3306,
                        'user' => 'root',
                    ],
                ];
            },
            'doctrine.dbal.db.event_manager' => static function (ContainerInterface $container) {
                /** @var Container $dbEvents */
                $dbEvents = $container->get('doctrine.dbal.dbs.event_manager');

                return $dbEvents->get($container->get('doctrine.dbal.dbs.default'));
            },
            'doctrine.dbal.dbs' => static function (ContainerInterface $container) {
                $container->get('doctrine.dbal.dbs.options.initializer')();

                $dbs = new Container();
                foreach ($container->get('doctrine.dbal.dbs.options') as $name => $options) {
                    if ($container->get('doctrine.dbal.dbs.default') === $name) {
                        $config = $container->get('doctrine.dbal.db.config');
                        $manager = $container->get('doctrine.dbal.db.event_manager');
                    } else {
                        $config = $container->get('doctrine.dbal.dbs.config')->get($name);
                        $manager = $container->get('doctrine.dbal.dbs.event_manager')->get($name);
                    }

                    $dbs->factory($name, static function () use ($options, $config, $manager) {
                        return DriverManager::getConnection($options['connection'], $config, $manager);
                    });
                }

                return $dbs;
            },
            'doctrine.dbal.dbs.config' => static function (ContainerInterface $container) {
                $container->get('doctrine.dbal.dbs.options.initializer')();

                $logger = $container->has('logger') ? $container->get('logger') : null;

                $cache = function (array $cacheDefinition) use ($container): Cache {
                    $cacheType = $cacheDefinition['type'];
                    $cacheOptions = $cacheDefinition['options'] ?? [];

                    $cacheFactory = $container->get(sprintf('doctrine.dbal.db.cache_factory.%s', $cacheType));

                    return $cacheFactory($cacheOptions);
                };

                $configs = new Container();
                foreach ($container->get('doctrine.dbal.dbs.options') as $name => $options) {
                    $configs->factory($name, function () use ($logger, $cache, $options) {
                        $configOptions = $options['configuration'];

                        $config = new Configuration();

                        if (null !== $logger) {
                            $config->setSQLLogger(new DoctrineDbalLogger($logger));
                        }

                        $config->setResultCacheImpl($cache($configOptions['cache.result']));

                        if (null !== $configOptions['filter_schema_assets_expression']) {
                            // @deprecated
                            $config->setFilterSchemaAssetsExpression($configOptions['filter_schema_assets_expression']);

The function Doctrine\DBAL\Configuration::setFilterSchemaAssetsExpression() has been deprecated: Use Configuration::setSchemaAssetsFilter() instead

                        }

                        if (null !== $configOptions['schema_assets_filter']) {
                            $config->setSchemaAssetsFilter($configOptions['schema_assets_filter']);
                        }

                        $config->setAutoCommit($configOptions['auto_commit']);

                        return $config;
                    });
                }

                return $configs;
            },
            'doctrine.dbal.dbs.event_manager' => static function (ContainerInterface $container) {
                $container->get('doctrine.dbal.dbs.options.initializer')();

                $managers = new Container();
                foreach ($container->get('doctrine.dbal.dbs.name') as $name) {
                    $managers->factory((string) $name, static function () {
                        return new EventManager();
                    });
                }

                return $managers;
            },
            'doctrine.dbal.dbs.name' => static function (ContainerInterface $container) {
                $container->get('doctrine.dbal.dbs.options.initializer')();

                return array_keys($container->get('doctrine.dbal.dbs.options'));
            },
            'doctrine.dbal.dbs.options.initializer' => static function (ContainerInterface $container) {
                return static function () use ($container): void {
                    static $initialized = false;

                    if ($initialized) {
                        return;
                    }

                    $initialized = true;

                    foreach ((array) $container->get('doctrine.dbal.types') as $typeName => $typeClass) {
                        if (Type::hasType($typeName)) {
                            Type::overrideType($typeName, $typeClass);
                        } else {
                            Type::addType($typeName, $typeClass);
                        }
                    }

                    if (!$container->has('doctrine.dbal.dbs.options')) {
                        $container->factory('doctrine.dbal.dbs.options', static function (ContainerInterface $container) {
                            return [
                                'default' => $container->has('doctrine.dbal.db.options')
                                    ? $container->get('doctrine.dbal.db.options')
                                    : [],
                            ];
                        });
                    }

                    $tmp = $container->get('doctrine.dbal.dbs.options');
                    foreach ($tmp as $name => &$options) {
                        $options = array_replace_recursive(
                            $container->get('doctrine.dbal.db.default_options'),
                            $options
                        );

                        if (!$container->has('doctrine.dbal.dbs.default')) {
                            $container->factory('doctrine.dbal.dbs.default', function () use ($name) {
                                return $name;
                            });
                        }
                    }

                    $container->factory('doctrine.dbal.dbs.options', function () use ($tmp) {
                        return $tmp;
                    });
                };
            },
            'doctrine.dbal.types' => function () {
                return [];
            },
        ];
    }
}