Final Class Yiisoft\Db\Migration\Service\MigrationService

                public function __construct(
    private readonly ConnectionInterface $db,
    private readonly Injector $injector,
    private readonly Migrator $migrator,
) {}

            

                public function before(string $commandName): int
{
    switch ($commandName) {
        case 'migrate:create':
            if (empty($this->newMigrationNamespace) && empty($this->newMigrationPath)) {
                $this->io?->error(
                    'One of `newMigrationNamespace` or `newMigrationPath` should be specified.',
                );
                return Command::INVALID;
            }
            if (!empty($this->newMigrationNamespace) && !empty($this->newMigrationPath)) {
                $this->io?->error(
                    'Only one of `newMigrationNamespace` or `newMigrationPath` should be specified.',
                );
                return Command::INVALID;
            }
            break;
        case 'migrate:up':
            if (empty($this->sourceNamespaces) && empty($this->sourcePaths)) {
                $this->io?->error(
                    'At least one of `sourceNamespaces` or `sourcePaths` should be specified.',
                );
                return Command::INVALID;
            }
            break;
    }
    return Command::SUCCESS;
}

            

                public function databaseConnection(): void
{
    $this->io?->writeln(
        "<fg=cyan>Database connection: {$this->db->getDriverName()}.</>",
    );
}

            

                public function filterMigrations(array $classes, array $namespaces = [], array $paths = []): array
{
    $result = [];
    $pathNamespaces = [];
    foreach ($paths as $path) {
        $pathNamespaceList = $this->getNamespacesFromPath($path);
        if (!empty($pathNamespaceList)) {
            $pathNamespaces[$path] = $pathNamespaceList;
        }
    }
    $namespaces = array_map(static fn($namespace) => trim($namespace, '\\'), $namespaces);
    $namespaces = array_unique($namespaces);
    foreach ($classes as $class) {
        $classNamespace = substr($class, 0, strrpos($class, '\\') ?: 0);
        if ($classNamespace === '') {
            continue;
        }
        if (in_array($classNamespace, $namespaces, true)) {
            $result[] = $class;
            continue;
        }
        foreach ($pathNamespaces as $path => $pathNamespaceList) {
            /** @psalm-suppress RedundantCondition */
            if (!in_array($classNamespace, $pathNamespaceList, true)) {
                continue;
            }
            /** @var string $className */
            $className = strrchr($class, '\\');
            $className = substr($className, 1);
            $file = $path . DIRECTORY_SEPARATOR . $className . '.php';
            if (is_file($file)) {
                $result[] = $class;
                break;
            }
        }
    }
    return $result;
}

            

                public function findMigrationPath(): string
{
    return empty($this->newMigrationNamespace)
        ? $this->newMigrationPath
        : $this->getNamespacePath($this->newMigrationNamespace);
}

            

                public function generateClassName(string $name): string
{
    /** @var string $words */
    $words = preg_replace('/[^a-z0-9]+/i', ' ', $name);
    return 'M' . gmdate('ymdHis') . str_replace(' ', '', ucwords($words));
}

            

                public function getNewMigrationNamespace(): string
{
    return $this->newMigrationNamespace;
}

            

                public function getNewMigrations(): array
{
    $applied = [];
    foreach ($this->migrator->getHistory() as $class => $time) {
        $applied[trim($class, '\\')] = true;
    }
    $migrationPaths = [];
    foreach ($this->sourcePaths as $path) {
        $migrationPaths[] = [$path, ''];
    }
    foreach ($this->sourceNamespaces as $namespace) {
        $migrationPaths[] = [$this->getNamespacePath($namespace), $namespace];
    }
    $migrations = [];
    foreach ($migrationPaths as $item) {
        [$sourcePath, $namespace] = $item;
        if (!is_dir($sourcePath)) {
            continue;
        }
        /** @var resource $handle */
        $handle = opendir($sourcePath);
        while (($file = readdir($handle)) !== false) {
            if ($file === '.' || $file === '..') {
                continue;
            }
            $path = $sourcePath . DIRECTORY_SEPARATOR . $file;
            if (is_file($path) && preg_match('/^(M(\d{12}).*)\.php$/s', $file, $matches)) {
                [, $class, $time] = $matches;
                if (!empty($namespace)) {
                    $class = $namespace . '\\' . $class;
                }
                /** @psalm-var class-string $class */
                if (!isset($applied[$class])) {
                    $migrations[$time . '\\' . $class] = $class;
                }
            }
        }
        closedir($handle);
    }
    ksort($migrations);
    return array_values($migrations);
}

            

                public function makeMigration(string $class): MigrationInterface
{
    $migration = $this->makeMigrationInstance($class);
    if (!$migration instanceof MigrationInterface) {
        throw new RuntimeException("Migration $class does not implement MigrationInterface.");
    }
    return $migration;
}

            

                public function makeMigrations(array $classes): array
{
    return array_map(
        $this->makeMigration(...),
        $classes,
    );
}

            

                public function makeRevertibleMigration(string $class): RevertibleMigrationInterface
{
    $migration = $this->makeMigrationInstance($class);
    if (!$migration instanceof RevertibleMigrationInterface) {
        throw new RuntimeException("Migration $class does not implement RevertibleMigrationInterface.");
    }
    return $migration;
}

            

                public function makeRevertibleMigrations(array $classes): array
{
    return array_map(
        $this->makeRevertibleMigration(...),
        $classes,
    );
}

            

                public function setIo(?SymfonyStyle $io): void
{
    $this->io = $io;
}

            

                public function setNewMigrationNamespace(string $value): void
{
    $this->newMigrationNamespace = $value;
}

            

                public function setNewMigrationPath(string $value): void
{
    $this->newMigrationPath = $value;
}

            

                public function setSourceNamespaces(array $value): void
{
    $this->sourceNamespaces = $value;
}

            

                public function setSourcePaths(array $value): void
{
    $this->sourcePaths = $value;
}

            

                public function version(): string
{
    return $this->version;
}