Inject EM dynamically into UniqueEntity constraint

[kAlvaro]

I'm using Symfony 5.4 LTS. UniqueEntity provides the exact validation I need. Unfortunately, em needs to be hard-coded and that doesn't work for me because mine is a multi-tenancy application. Validation crashes with a SQL error because it invokes the right repository method in the wrong EM.

I have an injectable service class that provides access to the right EM, but MyEntityClass::loadValidatorMetadata is a static method and I don't see an obvious way to use DI from there.

Is there a clean way to use this builtin constraint in my case?

[stof]

My suggestion would be to create a custom constraint, for which the ConstraintValidator would reuse the UniqueEntity with the appropriate configuration:

use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;
use Symfony\Component\Validator\Exception\UnexpectedTypeException;

class MyUniqueEntityValidator extends ConstraintValidator
{
    public function validate(mixed $value, Constraint $constraint): void
    {
        if (!$constraint instanceof MyUniqueEntity) {
            throw new UnexpectedTypeException($constraint, MyUniqueEntity::class);
        }

        $em = 'foo'; // Put the logic to choose the entity manager here

        $this->context->getValidator()
            ->inContext($this->context)
            ->validate($value, new UniqueEntity(em: $em));
    }
}

[kAlvaro]

Thank you so much. I got lost while trying to implement your solution, because I have very little experience with Symfony validation and the project has accumulated a few homebrew approaches along the years that make it hard to learn from existing logic. But you got me a great idea and I finally managed to do it by extending both builtin constraint and validator and pluging my service in the validator.

<?php

namespace Redacted\Validator\Constraints;

use Redacted\Validator\CustomUniqueEntityValidator;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;

/**
 * @Annotation
 */
class CustomUniqueEntity extends UniqueEntity
{
    public function validatedBy(): string
    {
        return CustomUniqueEntityValidator::class;
    }
}

<?php

namespace Redacted\Validator;

use Doctrine\Persistence\ManagerRegistry;
use Redacted\Service\MyEntityManagerService;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntityValidator;
use Symfony\Component\Validator\Constraint;

class CustomUniqueEntityValidator extends UniqueEntityValidator
{
    public function __construct(
        ManagerRegistry $registry,
        protected readonly MyEntityManagerService $myEntityManagerService,
    ) {
        parent::__construct($registry);
    }

    public function validate($entity, Constraint $constraint)
    {
        $constraint->em = $this->myEntityManagerService->getEntityManagerName();
        return parent::validate($entity, $constraint);
    }
}

[stof]

Don't use inheritance from the Symfony classes. Create a custom constraint MyUniqueEntity in my example) and make its constraint validator delegate to the UniqueEntity constraint.

Note that I realize that my code snippet is imcomplete. the instantiation of the UniqueEntity constraint (new UniqueEntity(em: $em) in my snippet) should also configure the other options of that constraint, not just em (whether you hardcode them or copy them from some properties of your own custom constraint to keep that configurable for different usages depends on your use case)

[kAlvaro]

Note that I realize that my code snippet is imcomplete

Yes, don't worry, I got stuck somewhere else (all this logic is triggered automagically and any missing bit breaks the chain without error messages).

Don't use inheritance from the Symfony classes

Is there something wrong in using inheritance to solve this? I mean, it's extremely convenient at first sight.