Fix TuuidType exceptions, improve unit and integration tests, add Doctrine type registration test

Author: CreativeNative

README.md

@@ -64,13 +64,11 @@ Configure your available locales and, optionally, the default one and disabled f
 ```yaml
 # config/packages/tmi_translation.yaml
 tmi_translation:
-    locales: [en, fr, ja]            # Required: available locales
-    # default_locale: en             # Optional: uses kernel.default_locale if not set
-    # disabled_firewalls: ['admin']  # Optional: disable filter for specific firewalls
+    locales: ['en_US', 'de_DE', 'it_IT'] # Required: available locales
+    # default_locale: 'en_US'            # Optional: uses kernel.default_locale if not set
+    # disabled_firewalls: ['main']       # Optional: disable filter for specific firewalls
 ```
 
-
-
 ## 🚀 Quick Start
 
 ### Make your entity translatable
@@ -103,7 +101,7 @@ class Product implements TranslatableInterface
 Use the service `tmi_translation.translator.entity_translator` to translate a source entity to a target language.
 
 ```php
-$translatedEntity = $this->get('tmi_translation.translator.entity_translator')->translate($entity, 'de');
+$translatedEntity = $this->get('tmi_translation.translator.entity_translator')->translate($entity, 'de_DE');
 ```
 
 Every attribute of the source entity will be cloned into a new entity, unless specified otherwise with the `EmptyOnTranslate`
@@ -179,7 +177,7 @@ For doing so, you can disable the filter by configuring the disabled_firewalls o
 # config/packages/tmi_translation.yaml
 tmi_translation:
   locales: [en, de, it]
-  disabled_firewalls: ['admin']  # Disable filter for 'admin' firewall
+  disabled_firewalls: ['main']  # Disable filter for 'main' firewall
 ```
 
 ### Quick Fix for unique fields

composer.json

@@ -84,6 +84,17 @@
         "rector": [
             "Composer\\Config::disableProcessTimeout",
             "vendor/bin/rector process --dry-run"
+        ],
+        "check": [
+            "@test",
+            "@cs-check",
+            "@stan-min"
+        ],
+        "post-install-cmd": [
+            "@check"
+        ],
+        "post-update-cmd": [
+            "@check"
         ]
     },
     "config": {

src/Doctrine/Model/TranslatableInterface.php

@@ -10,8 +10,6 @@ interface TranslatableInterface
 {
     public function getTuuid(): Tuuid|null;
 
-    public function setTuuid(Tuuid|null $tuuid): self;
-
     public function getLocale(): string|null;
 
     public function setLocale(string|null $locale = null): self;

src/Doctrine/Model/TranslatableTrait.php

@@ -6,17 +6,16 @@
 
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
-use Symfony\Component\Uid\Uuid;
 use Tmi\TranslationBundle\Doctrine\Attribute\SharedAmongstTranslations;
 use Tmi\TranslationBundle\ValueObject\Tuuid;
 
 trait TranslatableTrait
 {
-    #[ORM\Column(type: Types::GUID, length: 36, nullable: true)]
+    #[ORM\Column(type: 'tuuid', length: 36, nullable: true)]
     #[SharedAmongstTranslations]
     private Tuuid|null $tuuid = null;
 
-    #[ORM\Column(type: Types::STRING, length: 7, nullable: true)]
+    #[ORM\Column(type: Types::STRING, length: 5, nullable: true)]
     private string|null $locale = null;
 
     #[ORM\Column(type: Types::JSON)]
@@ -25,7 +24,7 @@ trait TranslatableTrait
     final public function generateTuuid(): void
     {
         if (null === $this->tuuid) {
-            $this->tuuid = new Tuuid(Uuid::v4()->toRfc4122());
+            $this->tuuid = Tuuid::generate();
         }
     }
 
@@ -34,16 +33,33 @@ final public function generateTuuid(): void
      */
     final public function setTuuid(Tuuid|null $tuuid): self
     {
-        $this->tuuid = $tuuid;
+        // Initial assignment always allowed (including null for cloning/tests)
+        if (null === $this->tuuid) {
+            $this->tuuid = $tuuid;
 
-        return $this;
+            return $this;
+        }
+
+        // Doctrine rehydration of the same value:
+        // - Only applies if both sides are Tuuid instances
+        // - Compare via Tuuid::equals()
+        if ($tuuid instanceof Tuuid && $this->tuuid->equals($tuuid)) {
+            return $this;
+        }
+
+        // Everything else would reassign a previously set Tuuid
+        throw new \LogicException('Tuuid is immutable and cannot be reassigned.');
     }
 
     /**
      * Returns entity's Translation UUID.
      */
-    final public function getTuuid(): Tuuid|null
+    final public function getTuuid(): Tuuid
     {
+        if (null === $this->tuuid) {
+            $this->tuuid = Tuuid::generate();
+        }
+
         return $this->tuuid;
     }
 

src/Doctrine/Type/TuuidType.php

@@ -7,42 +7,55 @@
 use Doctrine\DBAL\Platforms\AbstractPlatform;
 use Doctrine\DBAL\Types\ConversionException;
 use Doctrine\DBAL\Types\GuidType;
+use Symfony\Component\Uid\Uuid;
 use Tmi\TranslationBundle\ValueObject\Tuuid;
 
 final class TuuidType extends GuidType
 {
     public const string NAME = 'tuuid';
 
-    #[\Override]
-    public function convertToPHPValue($value, AbstractPlatform $platform): Tuuid|null
+    public function convertToPHPValue(mixed $value, AbstractPlatform $platform): Tuuid|null
     {
         if (null === $value) {
-            return null;
+            return Tuuid::generate();
         }
 
-        try {
+        if ($value instanceof Tuuid) {
+            return $value;
+        }
+
+        if (is_string($value) && Uuid::isValid($value)) {
             return new Tuuid($value);
-        } catch (\InvalidArgumentException $e) {
-            throw new ConversionException(sprintf('Cannot convert "%s" to Tuuid', $value), 0, $e);
         }
+
+        throw new ConversionException(sprintf('Cannot convert "%s" to Tuuid (PHPValue)', get_debug_type($value)));
     }
 
-    #[\Override]
-    public function convertToDatabaseValue($value, AbstractPlatform $platform): string|null
+    public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): string|null
     {
         if (null === $value) {
-            return null;
+            return Tuuid::generate()->getValue();
+        }
+
+        if ($value instanceof Tuuid) {
+            return $value->getValue();
         }
 
-        if (!$value instanceof Tuuid) {
-            throw new \InvalidArgumentException('Value must be a Tuuid object.');
+        if (is_string($value) && Uuid::isValid($value)) {
+            return new Tuuid($value)->getValue();
         }
 
-        return (string) $value;
+        throw new ConversionException(sprintf('Cannot convert "%s" to Tuuid (DatabaseValue)', get_debug_type($value)));
     }
 
     public function getName(): string
     {
         return self::NAME;
     }
+
+    public function getMappedDatabaseTypes(AbstractPlatform $platform): array
+    {
+        // So that SchemaTool does not cause any problems during mapping
+        return ['guid'];
+    }
 }

src/Translation/EntityTranslator.php

@@ -85,21 +85,25 @@ public function processTranslation(TranslationArgs $args): mixed
 
         // Handle top-level entities that implement TranslatableInterface
         if ($entity instanceof TranslatableInterface) {
-            $tuuid    = $entity->getTuuid();
-            $cacheKey = $tuuid instanceof Tuuid ? $tuuid->getValue().':'.$locale : null;
+            $cacheKey = null;
+
+            $tuuid = $entity->getTuuid();
+            if ($tuuid instanceof Tuuid && !empty($tuuid->getValue())) {
+                $cacheKey = $tuuid->getValue().':'.$locale;
+            }
 
             // Return cached translation immediately if available
-            if ($cacheKey && isset($this->translationCache[(string) $tuuid][$locale])) {
+            if (null !== $cacheKey && isset($this->translationCache[(string) $tuuid][$locale])) {
                 return $this->translationCache[(string) $tuuid][$locale];
             }
 
             // Detect cycles to avoid infinite recursion
-            if ($cacheKey && isset($this->inProgress[$cacheKey])) {
+            if (null !== $cacheKey && isset($this->inProgress[$cacheKey])) {
                 return $entity;
             }
 
             // Mark as in-progress and attempt to warm up existing translations from the database
-            if ($cacheKey) {
+            if (null !== $cacheKey) {
                 $this->inProgress[$cacheKey] = true;
                 // Warmup existing translations from DB
                 $this->warmupTranslations([$entity], $locale);
@@ -167,21 +171,17 @@ public function processTranslation(TranslationArgs $args): mixed
 
             $translated = $handler->translate($args);
 
-            // POST_TRANSLATE event
             if ($entity instanceof TranslatableInterface && $translated instanceof TranslatableInterface) {
+                // POST_TRANSLATE event
                 $this->eventDispatcher->dispatch(
                     new TranslateEvent($entity, $locale, $translated),
                     TranslateEvent::POST_TRANSLATE,
                 );
-            }
 
-            // Store translation in cache for reuse
-            if ($translated instanceof TranslatableInterface && null !== $translated->getTuuid()) {
+                // Store translation in cache for reuse
                 $this->translationCache[$translated->getTuuid()->getValue()][$translated->getLocale()] = $translated;
-            }
 
-            // Remove from in-progress set
-            if ($entity instanceof TranslatableInterface && null !== $entity->getTuuid()) {
+                // Remove from in-progress set
                 unset($this->inProgress[$entity->getTuuid()->getValue().':'.$locale]);
             }
 
@@ -238,10 +238,10 @@ private function warmupTranslations(array $entities, string $locale): void
                 continue;
             }
             $tuuid = $entity->getTuuid();
-            if (null === $tuuid || isset($this->translationCache[(string) $tuuid][$locale])) {
+            if (isset($this->translationCache[(string) $tuuid][$locale])) {
                 continue;
             }
-            $byClass[$entity::class][] = (string) $tuuid;
+            $byClass[$entity::class][] = $tuuid->getValue();
         }
 
         /** @var class-string<TranslatableInterface> $class */
@@ -265,7 +265,7 @@ private function warmupTranslations(array $entities, string $locale): void
 
             foreach ($translations as $translation) {
                 // @codeCoverageIgnoreStart
-                $this->translationCache[(string) $translation->getTuuid()][$translation->getLocale()] = $translation;
+                $this->translationCache[$translation->getTuuid()->getValue()][$translation->getLocale()] = $translation;
                 // @codeCoverageIgnoreEnd
             }
         }

src/ValueObject/Tuuid.php

@@ -41,7 +41,7 @@ public function __toString(): string
     public static function generate(): self
     {
         // Creates a new UUIDv7 (time-based, SEO-friendly sequence)
-        return new self(Uuid::v7()->toRfc4122());
+        return new self(strtolower(Uuid::v7()->toRfc4122()));
     }
 
     /**

tests/DependencyInjection/TmiTranslationExtensionTest.php

@@ -4,15 +4,20 @@
 
 namespace Tmi\TranslationBundle\Test\DependencyInjection;
 
+use Doctrine\DBAL\Exception;
+use Doctrine\DBAL\Types\Exception\TypesException;
+use Doctrine\DBAL\Types\Type;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Tmi\TranslationBundle\DependencyInjection\TmiTranslationExtension;
+use Tmi\TranslationBundle\Doctrine\Type\TuuidType;
 use Tmi\TranslationBundle\EventSubscriber\LocaleFilterConfigurator;
 
 final class TmiTranslationExtensionTest extends TestCase
 {
     /**
-     * @throws \Exception
+     * @throws TypesException
+     * @throws Exception
      */
     public function testLoad(): void
     {
@@ -23,7 +28,7 @@ public function testLoad(): void
             [
                 'locales'            => ['en_US', 'de_DE', 'it_IT'],
                 'default_locale'     => 'en_US',
-                'disabled_firewalls' => ['admin'],
+                'disabled_firewalls' => ['main'],
             ],
         ];
         $extension->load($config, $container);
@@ -51,4 +56,43 @@ public function testPrependDoesNothing(): void
         // Assert the container is still an instance of ContainerBuilder
         $this->assertInstanceOf(ContainerBuilder::class, $container);
     }
+
+    /**
+     * @throws Exception
+     * @throws TypesException
+     * @throws \ReflectionException
+     */
+    public function testDoctrineTypeRegistration(): void
+    {
+        // Unregister TuuidType if it exists
+        if (Type::hasType(TuuidType::NAME)) {
+            $reflection = new \ReflectionClass(Type::class);
+            $typesMap   = $reflection->getProperty('typesMap');
+            $map        = $typesMap->getValue();
+            unset($map[TuuidType::NAME]);
+            $typesMap->setValue(null, $map);
+        }
+
+        $this->assertFalse(
+            Type::hasType(TuuidType::NAME) && Type::getType(TuuidType::NAME) instanceof TuuidType,
+            'TuuidType should not be registered yet',
+        );
+
+        $container = new ContainerBuilder();
+        $extension = new TmiTranslationExtension();
+
+        $config = [
+            [
+                'locales'        => ['en_US', 'de_DE'],
+                'default_locale' => 'en_US',
+            ],
+        ];
+
+        $extension->load($config, $container);
+
+        $this->assertTrue(Type::hasType(TuuidType::NAME), 'TuuidType should be registered by the extension');
+
+        $typeInstance = Type::getType(TuuidType::NAME);
+        $this->assertInstanceOf(TuuidType::class, $typeInstance, 'Registered type should be an instance of TuuidType');
+    }
 }