Allow per-entity instance primary locales

[mpdude]

For now, each entity class has one fixed primary locale, expressed through the Locale attribute.

We have encountered cases in which some records were only available in a language different from the primary locale.

Therefore, it would be nice if we could remove the primary locale attribute and retrieve this information from a property, on a per-entity instance level. This would allow every entity instance to define its own primary locale.

[martingold]

Thank you for the wonderful library.

I am now refactoring an application where the primary language of the entity is stored in different entity (😐) and this issue is a blocker for me to use this nice library. I was thinking of two approaches to this. Just ideas and I would like to discuss them before implementing them.

Interface

• Introduce new interface DynamicLocaleEntity (just placeholder name for now)
• Handle case when the entity is instance of DynamicLocaleEntity and has attribute at same time
• Check if given entity is instance of DynamicLocaleEntity in TranslatableClassMetadata::injectNewPersistentTranslatables
• If so, use the getLocale() value instead the attribute value

  interface DynamicLocaleEntity
  {
  public function getLocale(): string;
  }

public function injectNewPersistentTranslatables(object $entity, EntityManager $entityManager, DefaultLocaleProvider $defaultLocaleProvider): void
    {
        foreach ($this->translatedProperties as $fieldName => $property) {
            $persistentTranslatable = new PersistentTranslatable(
                $entityManager->getUnitOfWork(),
                $this->class,
                $entity,
                // Handle case of missing #[Locale] attribute while no being instance of DynamicLocaleEntity
                $entity instanceof DynamicLocaleEntity ? $entity->getLocale() : $this->primaryLocale,
                $defaultLocaleProvider,
                $this->translationFieldMapping[$fieldName],
                $this->translationsCollectionProperty,
                $this->translationClass,
                $this->translationLocaleProperty,
                $this->translationMappingProperty,
                $property,
                $this->logger
            );
            $persistentTranslatable->inject();
        }
    }

• Con: polluting every translatable entity with new method and interface (the interface seems rather pointless), very inconsistent since the library uses attributes everywhere else
• Pro: easier to implement, less magical than the other approach

Questions: Is the Locale attribute needed? The getLocale() could return literal string.

Extend Locale attribute

• Add property method and property to Locale attribute
• Ensure only one of primaryLocale, method or property is defined
• Add primaryLocaleMethod and primaryLocaleProperty properties to TranslatableClassMetadata

• Include logic for fetching the primaryLocale to injectNewPersistentTranslatables

  #[Entity]
  #[Locale(method: 'getEventLanguage')]
  class Event
  {
  public function getEventLanguage(): string
  {
      return $this->...
  }
  }

  #[Entity]
  #[Locale(property: 'locale')]
  class Event
  {
  public string $locale;
  }

  public function injectNewPersistentTranslatables(object $entity, EntityManager $entityManager, DefaultLocaleProvider $defaultLocaleProvider): void
  {
      // More robust error handling needed to include reason and how to fixit → Method Event::getLocale() does not exist. Implement it or check if method specified in attribute #[Locale] of App\Entity\Event exists.
      $entityLocale = match (true) {
          $this->primaryLocale !== null => $this->primaryLocale,
          $this->primaryLocaleMethod !== null => call_user_func([$entity, 'primaryLocaleMethod']),
          $this->primaryLocaleProperty !== null => $entity->{$this->primaryLocaleProperty},
          default => throw new LogicException('...'), // Should be checked by the Locale attribute 
      };
  
      foreach ($this->translatedProperties as $fieldName => $property) {
          $persistentTranslatable = new PersistentTranslatable(
              $entityManager->getUnitOfWork(),
              $this->class,
              $entity,
              $entityLocale,
              $defaultLocaleProvider,
              $this->translationFieldMapping[$fieldName],
              $this->translationsCollectionProperty,
              $this->translationClass,
              $this->translationLocaleProperty,
              $this->translationMappingProperty,
              $property,
              $this->logger
          );
          $persistentTranslatable->inject();
      }
  }

  Pro: more versatile and useful. Does not pollute every translatable entity with interface implementation Con: calling method/getting property based on a string is a bit yikes and it may be very error-prone (would it not be nice if PHP supported first class callable syntax in attributes? 😁).

Questions:

• Should the private properties be supported?
• If no is the property access even worth implementing?

Which of these two approaches would have better chance of getting merged if i were to implement it? Am I missing something critical @mpdude ?

Thank you!