vendor/doctrine/migrations/lib/Doctrine/Migrations/DependencyFactory.php line 346

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\Migrations;
  7. use Doctrine\DBAL\Connection;
  8. use Doctrine\Migrations\Configuration\Configuration;
  9. use Doctrine\Migrations\Configuration\Connection\ConnectionLoader;
  10. use Doctrine\Migrations\Configuration\EntityManager\EntityManagerLoader;
  11. use Doctrine\Migrations\Configuration\Migration\ConfigurationLoader;
  12. use Doctrine\Migrations\Exception\FrozenDependencies;
  13. use Doctrine\Migrations\Exception\MissingDependency;
  14. use Doctrine\Migrations\Finder\GlobFinder;
  15. use Doctrine\Migrations\Finder\MigrationFinder;
  16. use Doctrine\Migrations\Finder\RecursiveRegexFinder;
  17. use Doctrine\Migrations\Generator\ClassNameGenerator;
  18. use Doctrine\Migrations\Generator\ConcatenationFileBuilder;
  19. use Doctrine\Migrations\Generator\DiffGenerator;
  20. use Doctrine\Migrations\Generator\FileBuilder;
  21. use Doctrine\Migrations\Generator\Generator;
  22. use Doctrine\Migrations\Generator\SqlGenerator;
  23. use Doctrine\Migrations\Metadata\Storage\MetadataStorage;
  24. use Doctrine\Migrations\Metadata\Storage\TableMetadataStorage;
  25. use Doctrine\Migrations\Metadata\Storage\TableMetadataStorageConfiguration;
  26. use Doctrine\Migrations\Provider\DBALSchemaDiffProvider;
  27. use Doctrine\Migrations\Provider\EmptySchemaProvider;
  28. use Doctrine\Migrations\Provider\LazySchemaDiffProvider;
  29. use Doctrine\Migrations\Provider\OrmSchemaProvider;
  30. use Doctrine\Migrations\Provider\SchemaDiffProvider;
  31. use Doctrine\Migrations\Provider\SchemaProvider;
  32. use Doctrine\Migrations\Tools\Console\ConsoleInputMigratorConfigurationFactory;
  33. use Doctrine\Migrations\Tools\Console\Helper\MigrationStatusInfosHelper;
  34. use Doctrine\Migrations\Tools\Console\MigratorConfigurationFactory;
  35. use Doctrine\Migrations\Version\AliasResolver;
  36. use Doctrine\Migrations\Version\AlphabeticalComparator;
  37. use Doctrine\Migrations\Version\Comparator;
  38. use Doctrine\Migrations\Version\CurrentMigrationStatusCalculator;
  39. use Doctrine\Migrations\Version\DbalExecutor;
  40. use Doctrine\Migrations\Version\DbalMigrationFactory;
  41. use Doctrine\Migrations\Version\DefaultAliasResolver;
  42. use Doctrine\Migrations\Version\Executor;
  43. use Doctrine\Migrations\Version\MigrationFactory;
  44. use Doctrine\Migrations\Version\MigrationPlanCalculator;
  45. use Doctrine\Migrations\Version\MigrationStatusCalculator;
  46. use Doctrine\Migrations\Version\SortedMigrationPlanCalculator;
  47. use Doctrine\ORM\EntityManagerInterface;
  48. use Psr\Log\LoggerInterface;
  49. use Psr\Log\NullLogger;
  50. use Symfony\Component\Stopwatch\Stopwatch;
  52. use function array_key_exists;
  53. use function call_user_func;
  54. use function preg_quote;
  55. use function sprintf;
  57. /**
  58.  * The DependencyFactory is responsible for wiring up and managing internal class dependencies.
  59.  */
  60. class DependencyFactory
  61. {
  62.     /** @psalm-var array<string, bool> */
  63.     private $inResolution = [];
  65.     private ?Configuration $configuration = null;
  67.     /** @var object[]|callable[] */
  68.     private array $dependencies = [];
  70.     private ?Connection $connection = null;
  72.     private ?EntityManagerInterface $em = null;
  74.     private bool $frozen = false;
  76.     private ConfigurationLoader $configurationLoader;
  78.     private ConnectionLoader $connectionLoader;
  80.     private ?EntityManagerLoader $emLoader = null;
  82.     /** @var callable[] */
  83.     private array $factories = [];
  85.     public static function fromConnection(
  86.         ConfigurationLoader $configurationLoader,
  87.         ConnectionLoader $connectionLoader,
  88.         ?LoggerInterface $logger = null
  89.     ): self {
  90.         $dependencyFactory                      = new self($logger);
  91.         $dependencyFactory->configurationLoader = $configurationLoader;
  92.         $dependencyFactory->connectionLoader    = $connectionLoader;
  94.         return $dependencyFactory;
  95.     }
  97.     public static function fromEntityManager(
  98.         ConfigurationLoader $configurationLoader,
  99.         EntityManagerLoader $emLoader,
  100.         ?LoggerInterface $logger = null
  101.     ): self {
  102.         $dependencyFactory                      = new self($logger);
  103.         $dependencyFactory->configurationLoader = $configurationLoader;
  104.         $dependencyFactory->emLoader            = $emLoader;
  106.         return $dependencyFactory;
  107.     }
  109.     private function __construct(?LoggerInterface $logger)
  110.     {
  111.         if ($logger === null) {
  112.             return;
  113.         }
  115.         $this->setDefinition(LoggerInterface::class, static function () use ($logger): LoggerInterface {
  116.             return $logger;
  117.         });
  118.     }
  120.     public function isFrozen(): bool
  121.     {
  122.         return $this->frozen;
  123.     }
  125.     public function freeze(): void
  126.     {
  127.         $this->frozen = true;
  128.     }
  130.     private function assertNotFrozen(): void
  131.     {
  132.         if ($this->frozen) {
  133.             throw FrozenDependencies::new();
  134.         }
  135.     }
  137.     public function hasEntityManager(): bool
  138.     {
  139.         return $this->emLoader !== null;
  140.     }
  142.     public function setConfigurationLoader(ConfigurationLoader $configurationLoader): void
  143.     {
  144.         $this->assertNotFrozen();
  145.         $this->configurationLoader = $configurationLoader;
  146.     }
  148.     public function getConfiguration(): Configuration
  149.     {
  150.         if ($this->configuration === null) {
  151.             $this->configuration = $this->configurationLoader->getConfiguration();
  152.             $this->freeze();
  153.         }
  155.         return $this->configuration;
  156.     }
  158.     public function getConnection(): Connection
  159.     {
  160.         if ($this->connection === null) {
  161.             $this->connection = $this->hasEntityManager()
  162.                 ? $this->getEntityManager()->getConnection()
  163.                 : $this->connectionLoader->getConnection($this->getConfiguration()->getConnectionName());
  164.             $this->freeze();
  165.         }
  167.         return $this->connection;
  168.     }
  170.     public function getEntityManager(): EntityManagerInterface
  171.     {
  172.         if ($this->em === null) {
  173.             if ($this->emLoader === null) {
  174.                 throw MissingDependency::noEntityManager();
  175.             }
  177.             $this->em = $this->emLoader->getEntityManager($this->getConfiguration()->getEntityManagerName());
  178.             $this->freeze();
  179.         }
  181.         return $this->em;
  182.     }
  184.     public function getVersionComparator(): Comparator
  185.     {
  186.         return $this->getDependency(Comparator::class, static function (): AlphabeticalComparator {
  187.             return new AlphabeticalComparator();
  188.         });
  189.     }
  191.     public function getLogger(): LoggerInterface
  192.     {
  193.         return $this->getDependency(LoggerInterface::class, static function (): LoggerInterface {
  194.             return new NullLogger();
  195.         });
  196.     }
  198.     public function getEventDispatcher(): EventDispatcher
  199.     {
  200.         return $this->getDependency(EventDispatcher::class, function (): EventDispatcher {
  201.             return new EventDispatcher(
  202.                 $this->getConnection(),
  203.                 $this->getConnection()->getEventManager()
  204.             );
  205.         });
  206.     }
  208.     public function getClassNameGenerator(): ClassNameGenerator
  209.     {
  210.         return $this->getDependency(ClassNameGenerator::class, static function (): ClassNameGenerator {
  211.             return new ClassNameGenerator();
  212.         });
  213.     }
  215.     public function getSchemaDumper(): SchemaDumper
  216.     {
  217.         return $this->getDependency(SchemaDumper::class, function (): SchemaDumper {
  218.             $excludedTables = [];
  220.             $metadataConfig = $this->getConfiguration()->getMetadataStorageConfiguration();
  221.             if ($metadataConfig instanceof TableMetadataStorageConfiguration) {
  222.                 $excludedTables[] = sprintf('/^%s$/', preg_quote($metadataConfig->getTableName(), '/'));
  223.             }
  225.             return new SchemaDumper(
  226.                 $this->getConnection()->getDatabasePlatform(),
  227.                 $this->getConnection()->createSchemaManager(),
  228.                 $this->getMigrationGenerator(),
  229.                 $this->getMigrationSqlGenerator(),
  230.                 $excludedTables
  231.             );
  232.         });
  233.     }
  235.     private function getEmptySchemaProvider(): SchemaProvider
  236.     {
  237.         return $this->getDependency(EmptySchemaProvider::class, function (): SchemaProvider {
  238.             return new EmptySchemaProvider($this->connection->createSchemaManager());
  239.         });
  240.     }
  242.     public function hasSchemaProvider(): bool
  243.     {
  244.         try {
  245.             $this->getSchemaProvider();
  246.         } catch (MissingDependency $exception) {
  247.             return false;
  248.         }
  250.         return true;
  251.     }
  253.     public function getSchemaProvider(): SchemaProvider
  254.     {
  255.         return $this->getDependency(SchemaProvider::class, function (): SchemaProvider {
  256.             if ($this->hasEntityManager()) {
  257.                 return new OrmSchemaProvider($this->getEntityManager());
  258.             }
  260.             throw MissingDependency::noSchemaProvider();
  261.         });
  262.     }
  264.     public function getDiffGenerator(): DiffGenerator
  265.     {
  266.         return $this->getDependency(DiffGenerator::class, function (): DiffGenerator {
  267.             return new DiffGenerator(
  268.                 $this->getConnection()->getConfiguration(),
  269.                 $this->getConnection()->createSchemaManager(),
  270.                 $this->getSchemaProvider(),
  271.                 $this->getConnection()->getDatabasePlatform(),
  272.                 $this->getMigrationGenerator(),
  273.                 $this->getMigrationSqlGenerator(),
  274.                 $this->getEmptySchemaProvider()
  275.             );
  276.         });
  277.     }
  279.     public function getSchemaDiffProvider(): SchemaDiffProvider
  280.     {
  281.         return $this->getDependency(SchemaDiffProvider::class, function (): LazySchemaDiffProvider {
  282.             return LazySchemaDiffProvider::fromDefaultProxyFactoryConfiguration(
  283.                 new DBALSchemaDiffProvider(
  284.                     $this->getConnection()->createSchemaManager(),
  285.                     $this->getConnection()->getDatabasePlatform()
  286.                 )
  287.             );
  288.         });
  289.     }
  291.     private function getFileBuilder(): FileBuilder
  292.     {
  293.         return $this->getDependency(FileBuilder::class, static function (): FileBuilder {
  294.             return new ConcatenationFileBuilder();
  295.         });
  296.     }
  298.     private function getParameterFormatter(): ParameterFormatter
  299.     {
  300.         return $this->getDependency(ParameterFormatter::class, function (): ParameterFormatter {
  301.             return new InlineParameterFormatter($this->getConnection());
  302.         });
  303.     }
  305.     public function getMigrationsFinder(): MigrationFinder
  306.     {
  307.         return $this->getDependency(MigrationFinder::class, function (): MigrationFinder {
  308.             $configs              = $this->getConfiguration();
  309.             $needsRecursiveFinder = $configs->areMigrationsOrganizedByYear() || $configs->areMigrationsOrganizedByYearAndMonth();
  311.             return $needsRecursiveFinder ? new RecursiveRegexFinder() : new GlobFinder();
  312.         });
  313.     }
  315.     public function getMigrationRepository(): MigrationsRepository
  316.     {
  317.         return $this->getDependency(MigrationsRepository::class, function (): MigrationsRepository {
  318.             return new FilesystemMigrationsRepository(
  319.                 $this->getConfiguration()->getMigrationClasses(),
  320.                 $this->getConfiguration()->getMigrationDirectories(),
  321.                 $this->getMigrationsFinder(),
  322.                 $this->getMigrationFactory()
  323.             );
  324.         });
  325.     }
  327.     public function getMigrationFactory(): MigrationFactory
  328.     {
  329.         return $this->getDependency(MigrationFactory::class, function (): MigrationFactory {
  330.             return new DbalMigrationFactory($this->getConnection(), $this->getLogger());
  331.         });
  332.     }
  334.     /**
  335.      * @param object|callable $service
  336.      */
  337.     public function setService(string $id, $service): void
  338.     {
  339.         $this->assertNotFrozen();
  340.         $this->dependencies[$id] = $service;
  341.     }
  343.     public function getMetadataStorage(): MetadataStorage
  344.     {
  345.         return $this->getDependency(MetadataStorage::class, function (): MetadataStorage {
  346.             return new TableMetadataStorage(
  347.                 $this->getConnection(),
  348.                 $this->getVersionComparator(),
  349.                 $this->getConfiguration()->getMetadataStorageConfiguration(),
  350.                 $this->getMigrationRepository()
  351.             );
  352.         });
  353.     }
  355.     private function getVersionExecutor(): Executor
  356.     {
  357.         return $this->getDependency(Executor::class, function (): Executor {
  358.             return new DbalExecutor(
  359.                 $this->getMetadataStorage(),
  360.                 $this->getEventDispatcher(),
  361.                 $this->getConnection(),
  362.                 $this->getSchemaDiffProvider(),
  363.                 $this->getLogger(),
  364.                 $this->getParameterFormatter(),
  365.                 $this->getStopwatch()
  366.             );
  367.         });
  368.     }
  370.     public function getQueryWriter(): QueryWriter
  371.     {
  372.         return $this->getDependency(QueryWriter::class, function (): QueryWriter {
  373.             return new FileQueryWriter(
  374.                 $this->getFileBuilder(),
  375.                 $this->getLogger()
  376.             );
  377.         });
  378.     }
  380.     public function getVersionAliasResolver(): AliasResolver
  381.     {
  382.         return $this->getDependency(AliasResolver::class, function (): AliasResolver {
  383.             return new DefaultAliasResolver(
  384.                 $this->getMigrationPlanCalculator(),
  385.                 $this->getMetadataStorage(),
  386.                 $this->getMigrationStatusCalculator()
  387.             );
  388.         });
  389.     }
  391.     public function getMigrationStatusCalculator(): MigrationStatusCalculator
  392.     {
  393.         return $this->getDependency(MigrationStatusCalculator::class, function (): MigrationStatusCalculator {
  394.             return new CurrentMigrationStatusCalculator(
  395.                 $this->getMigrationPlanCalculator(),
  396.                 $this->getMetadataStorage()
  397.             );
  398.         });
  399.     }
  401.     public function getMigrationPlanCalculator(): MigrationPlanCalculator
  402.     {
  403.         return $this->getDependency(MigrationPlanCalculator::class, function (): MigrationPlanCalculator {
  404.             return new SortedMigrationPlanCalculator(
  405.                 $this->getMigrationRepository(),
  406.                 $this->getMetadataStorage(),
  407.                 $this->getVersionComparator()
  408.             );
  409.         });
  410.     }
  412.     public function getMigrationGenerator(): Generator
  413.     {
  414.         return $this->getDependency(Generator::class, function (): Generator {
  415.             return new Generator($this->getConfiguration());
  416.         });
  417.     }
  419.     public function getMigrationSqlGenerator(): SqlGenerator
  420.     {
  421.         return $this->getDependency(SqlGenerator::class, function (): SqlGenerator {
  422.             return new SqlGenerator(
  423.                 $this->getConfiguration(),
  424.                 $this->getConnection()->getDatabasePlatform()
  425.             );
  426.         });
  427.     }
  429.     public function getConsoleInputMigratorConfigurationFactory(): MigratorConfigurationFactory
  430.     {
  431.         return $this->getDependency(MigratorConfigurationFactory::class, function (): MigratorConfigurationFactory {
  432.             return new ConsoleInputMigratorConfigurationFactory(
  433.                 $this->getConfiguration()
  434.             );
  435.         });
  436.     }
  438.     public function getMigrationStatusInfosHelper(): MigrationStatusInfosHelper
  439.     {
  440.         return $this->getDependency(MigrationStatusInfosHelper::class, function (): MigrationStatusInfosHelper {
  441.             return new MigrationStatusInfosHelper(
  442.                 $this->getConfiguration(),
  443.                 $this->getConnection(),
  444.                 $this->getVersionAliasResolver(),
  445.                 $this->getMigrationPlanCalculator(),
  446.                 $this->getMigrationStatusCalculator(),
  447.                 $this->getMetadataStorage()
  448.             );
  449.         });
  450.     }
  452.     public function getMigrator(): Migrator
  453.     {
  454.         return $this->getDependency(Migrator::class, function (): Migrator {
  455.             return new DbalMigrator(
  456.                 $this->getConnection(),
  457.                 $this->getEventDispatcher(),
  458.                 $this->getVersionExecutor(),
  459.                 $this->getLogger(),
  460.                 $this->getStopwatch()
  461.             );
  462.         });
  463.     }
  465.     public function getStopwatch(): Stopwatch
  466.     {
  467.         return $this->getDependency(Stopwatch::class, static function (): Stopwatch {
  468.             return new Stopwatch(true);
  469.         });
  470.     }
  472.     public function getRollup(): Rollup
  473.     {
  474.         return $this->getDependency(Rollup::class, function (): Rollup {
  475.             return new Rollup(
  476.                 $this->getMetadataStorage(),
  477.                 $this->getMigrationRepository()
  478.             );
  479.         });
  480.     }
  482.     /**
  483.      * @return mixed
  484.      */
  485.     private function getDependency(string $id, callable $callback)
  486.     {
  487.         if (! isset($this->inResolution[$id]) && array_key_exists($id, $this->factories) && ! array_key_exists($id, $this->dependencies)) {
  488.             $this->inResolution[$id] = true;
  489.             $this->dependencies[$id] = call_user_func($this->factories[$id], $this);
  490.             unset($this->inResolution);
  491.         }
  493.         if (! array_key_exists($id, $this->dependencies)) {
  494.             $this->dependencies[$id] = $callback();
  495.         }
  497.         return $this->dependencies[$id];
  498.     }
  500.     public function setDefinition(string $id, callable $service): void
  501.     {
  502.         $this->assertNotFrozen();
  503.         $this->factories[$id] = $service;
  504.     }
  505. }