added a schema lock file to tdbm

Author: Kharhamel

.gitignore

@@ -16,3 +16,5 @@ vendor/*
 .phpunit.result.cache
 /phpbench.sh
 /xdebug/
+.php_cs.cache
+tdbm.lock.yml

composer.json

@@ -39,7 +39,8 @@
         "ext-PDO": "*",
         "ext-json": "*",
         "ext-hash": "*",
-        "ext-filter": "*"
+        "ext-filter": "*",
+        "brain-diminished/schema-version-control": "^1.0"
     },
     "require-dev" : {
         "phpunit/phpunit": "^7.4.4 || ^8.0.0",

src/TDBMSchemaAnalyzer.php

@@ -3,6 +3,7 @@
 
 namespace TheCodingMachine\TDBM;
 
+use BrainDiminished\SchemaVersionControl\SchemaVersionControlService;
 use Doctrine\Common\Cache\Cache;
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\Schema\Column;
@@ -12,12 +13,16 @@
 use Doctrine\DBAL\Types\DateType;
 use Doctrine\DBAL\Types\Type;
 use Mouf\Database\SchemaAnalyzer\SchemaAnalyzer;
+use TheCodingMachine\TDBM\Utils\ImmutableCaster;
+use TheCodingMachine\TDBM\Utils\RootProjectLocator;
 
 /**
  * This class is used to analyze the schema and return valuable information / hints.
  */
 class TDBMSchemaAnalyzer
 {
+    const schemaFileName =  'tdbm.lock.yml';
+
     private $connection;
 
     /**
@@ -40,6 +45,11 @@ class TDBMSchemaAnalyzer
      */
     private $schemaAnalyzer;
 
+    /**
+     * @var SchemaVersionControlService
+     */
+    private $schemaVersionControlService;
+
     /**
      * @param Connection     $connection     The DBAL DB connection to use
      * @param Cache          $cache          A cache service to be used
@@ -51,6 +61,7 @@ public function __construct(Connection $connection, Cache $cache, SchemaAnalyzer
         $this->connection = $connection;
         $this->cache = $cache;
         $this->schemaAnalyzer = $schemaAnalyzer;
+        $this->schemaVersionControlService = new SchemaVersionControlService($this->connection, self::getLockFilePath());
     }
 
     /**
@@ -67,53 +78,35 @@ public function getCachePrefix(): string
         return $this->cachePrefix;
     }
 
+    public static function getLockFilePath(): string
+    {
+        return RootProjectLocator::getRootLocationPath().self::schemaFileName;
+    }
+
     /**
      * Returns the (cached) schema.
-     *
-     * @return Schema
      */
-    public function getSchema(): Schema
+    public function getSchema(bool $ignoreCache = false): Schema
     {
         if ($this->schema === null) {
             $cacheKey = $this->getCachePrefix().'_immutable_schema';
-            if ($this->cache->contains($cacheKey)) {
+            if (!$ignoreCache && $this->cache->contains($cacheKey)) {
                 $this->schema = $this->cache->fetch($cacheKey);
+            } elseif (!file_exists(self::getLockFilePath())) {
+                throw new TDBMException('No tdbm lock file found. Please regenerate DAOs and Beans.');
             } else {
-                $this->schema = $this->connection->getSchemaManager()->createSchema();
-                $this->castSchemaToImmutable($this->schema);
+                $this->schema = $this->schemaVersionControlService->loadSchemaFile();
+                ImmutableCaster::castSchemaToImmutable($this->schema);
                 $this->cache->save($cacheKey, $this->schema);
             }
         }
 
         return $this->schema;
     }
 
-    private function castSchemaToImmutable(Schema $schema): void
+    public function generateLockFile(): void
     {
-        foreach ($schema->getTables() as $table) {
-            foreach ($table->getColumns() as $column) {
-                $this->toImmutableType($column);
-            }
-        }
-    }
-
-    /**
-     * Changes the type of a column to an immutable date type if the type is a date.
-     * This is needed because by default, when reading a Schema, Doctrine assumes a mutable datetime.
-     */
-    private function toImmutableType(Column $column): void
-    {
-        $mapping = [
-            Type::DATE => Type::DATE_IMMUTABLE,
-            Type::DATETIME => Type::DATETIME_IMMUTABLE,
-            Type::DATETIMETZ => Type::DATETIMETZ_IMMUTABLE,
-            Type::TIME => Type::TIME_IMMUTABLE
-        ];
-
-        $typeName = $column->getType()->getName();
-        if (isset($mapping[$typeName])) {
-            $column->setType(Type::getType($mapping[$typeName]));
-        }
+        $this->schemaVersionControlService->dumpSchema();
     }
 
     /**

src/Utils/ImmutableCaster.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace TheCodingMachine\TDBM\Utils;
+
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\DBAL\Types\Type;
+
+class ImmutableCaster
+{
+    public static function castSchemaToImmutable(Schema $schema): void
+    {
+        foreach ($schema->getTables() as $table) {
+            foreach ($table->getColumns() as $column) {
+                self::toImmutableType($column);
+            }
+        }
+    }
+
+    /**
+     * Changes the type of a column to an immutable date type if the type is a date.
+     * This is needed because by default, when reading a Schema, Doctrine assumes a mutable datetime.
+     */
+    private static function toImmutableType(Column $column): void
+    {
+        $mapping = [
+            Type::DATE => Type::DATE_IMMUTABLE,
+            Type::DATETIME => Type::DATETIME_IMMUTABLE,
+            Type::DATETIMETZ => Type::DATETIMETZ_IMMUTABLE,
+            Type::TIME => Type::TIME_IMMUTABLE
+        ];
+
+        $typeName = $column->getType()->getName();
+        if (isset($mapping[$typeName])) {
+            $column->setType(Type::getType($mapping[$typeName]));
+        }
+    }
+}

src/Utils/RootProjectLocator.php

@@ -0,0 +1,13 @@
+<?php
+
+
+namespace TheCodingMachine\TDBM\Utils;
+
+class RootProjectLocator
+{
+    public static function getRootLocationPath(): string
+    {
+        $reflection = new \ReflectionClass(\Composer\Autoload\ClassLoader::class);
+        return dirname($reflection->getFileName(), 3).'/';
+    }
+}

src/Utils/TDBMDaoGenerator.php

@@ -33,11 +33,6 @@
  */
 class TDBMDaoGenerator
 {
-    /**
-     * @var Schema
-     */
-    private $schema;
-
     /**
      * @var TDBMSchemaAnalyzer
      */
@@ -66,7 +61,6 @@ class TDBMDaoGenerator
     public function __construct(ConfigurationInterface $configuration, TDBMSchemaAnalyzer $tdbmSchemaAnalyzer)
     {
         $this->configuration = $configuration;
-        $this->schema = $tdbmSchemaAnalyzer->getSchema();
         $this->tdbmSchemaAnalyzer = $tdbmSchemaAnalyzer;
         $this->namingStrategy = $configuration->getNamingStrategy();
         $this->eventDispatcher = $configuration->getGeneratorEventDispatcher();
@@ -79,9 +73,11 @@ public function __construct(ConfigurationInterface $configuration, TDBMSchemaAna
      */
     public function generateAllDaosAndBeans(): void
     {
-        // TODO: check that no class name ends with "Base". Otherwise, there will be name clash.
+        $this->tdbmSchemaAnalyzer->generateLockFile();
+        $schema = $this->tdbmSchemaAnalyzer->getSchema();
 
-        $tableList = $this->schema->getTables();
+        // TODO: check that no class name ends with "Base". Otherwise, there will be name clash.
+        $tableList = $schema->getTables();
 
         // Remove all beans and daos from junction tables
         $junctionTables = $this->configuration->getSchemaAnalyzer()->detectJunctionTables(true);
@@ -97,7 +93,7 @@ public function generateAllDaosAndBeans(): void
 
         $beanDescriptors = [];
 
-        $beanRegistry = new BeanRegistry($this->configuration, $this->schema, $this->tdbmSchemaAnalyzer, $this->namingStrategy);
+        $beanRegistry = new BeanRegistry($this->configuration, $schema, $this->tdbmSchemaAnalyzer, $this->namingStrategy);
         foreach ($tableList as $table) {
             $beanDescriptors[] = $beanRegistry->addBeanForTable($table);
         }

tests/Commands/GenerateCommandTest.php

@@ -10,6 +10,7 @@
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\BufferedOutput;
 use Symfony\Component\Console\Output\OutputInterface;
+use TheCodingMachine\TDBM\TDBMSchemaAnalyzer;
 
 class GenerateCommandTest extends TDBMAbstractServiceTest
 {
@@ -24,9 +25,16 @@ public function testCall(): void
         $input = new ArrayInput([
         ], self::getInputDefinition());
 
+        //let's delete the lock file
+        $schemaFilePath = TDBMSchemaAnalyzer::getLockFilePath();
+        if (file_exists($schemaFilePath)) {
+            unlink($schemaFilePath);
+        }
         $result = $this->callCommand(new GenerateCommand($this->getConfiguration()), $input);
 
         $this->assertContains('Finished regenerating DAOs and beans', $result);
+        //Check that the lock file was generated
+        $this->assertFileExists($schemaFilePath);
     }
 
     /**

tests/TDBMDaoGeneratorTest.php

@@ -114,10 +114,19 @@ public function testDaoGeneration(): void
         touch($dummyFile);
         $this->assertFileExists($dummyFile);
 
+        //let's delete the lock file
+        $schemaFilePath = TDBMSchemaAnalyzer::getLockFilePath();
+        if (file_exists($schemaFilePath)) {
+            unlink($schemaFilePath);
+        }
+
         $this->tdbmDaoGenerator->generateAllDaosAndBeans();
 
         $this->assertFileNotExists($dummyFile);
 
+        //Check that the lock file was generated
+        $this->assertFileExists($schemaFilePath);
+
         // Let's require all files to check they are valid PHP!
         // Test the daoFactory
         require_once $this->rootPath . 'src/Test/Dao/Generated/DaoFactory.php';

tests/TDBMSchemaAnalyzerTest.php

@@ -23,6 +23,7 @@
 
 use Doctrine\Common\Cache\ArrayCache;
 use Mouf\Database\SchemaAnalyzer\SchemaAnalyzer;
+use TheCodingMachine\TDBM\Utils\ImmutableCaster;
 
 class TDBMSchemaAnalyzerTest extends TDBMAbstractServiceTest
 {
@@ -38,6 +39,26 @@ protected function setUp(): void
         $this->tdbmSchemaAnalyzer = new TDBMSchemaAnalyzer(self::getConnection(), new ArrayCache(), $schemaAnalyzer);
     }
 
+    public function testSchemaLock(): void
+    {
+        $schemaFromConnec = self::getConnection()->getSchemaManager()->createSchema();
+        $tableNames = [];
+        //lock file doesn't save the database name so we have to replace it manually.
+        foreach ($schemaFromConnec->getTableNames() as $tableName) {
+            $tableNames[] = str_replace('tdbm_testcase', 'public', $tableName);
+        }
+        ImmutableCaster::castSchemaToImmutable($schemaFromConnec);
+
+        $schemaAnalyzer = new SchemaAnalyzer(self::getConnection()->getSchemaManager(), new ArrayCache(), 'prefix_');
+        $cache = new ArrayCache();
+        $tdbmSchemaAnalyzer1 = new TDBMSchemaAnalyzer(self::getConnection(), $cache, $schemaAnalyzer);
+
+        $schemaFromAnalyser = $tdbmSchemaAnalyzer1->getSchema(true);
+        $schemaFromAnalyserCached = $tdbmSchemaAnalyzer1->getSchema();
+        $this->assertEquals($tableNames, $schemaFromAnalyser->getTableNames());
+        $this->assertEquals($schemaFromAnalyser->getTableNames(), $schemaFromAnalyserCached->getTableNames());
+    }
+
     public function testGetSchema(): void
     {
         $schemaAnalyzer = new SchemaAnalyzer(self::getConnection()->getSchemaManager(), new ArrayCache(), 'prefix_');