User registration unique email validation is not working when existing user is blocked

[alex3493]

When we try to register a new user with email already used by a blocked (soft-deleted) user validation error (409 - conflict) is not raised.
We get 500 server error due to SQL unique constraint violation.

[alex3493]

We enable soft-deleted filter in doctrine config:

filters:
    softDeleted:
        class: App\Module\Shared\Infrastructure\Persistence\Filter\SoftDeleteFilter
        enabled: true

It works in most cases, also we can successfully disable it in admin user list when withSoftDeleted option is true.

However, in Validator UniqueEntity rule this filter is applied by default making duplicate email error bypass validation, so we end up with 500 SQL error.

We have to find the way to ignore doctrine filters in UniqueEntity validation checks.

[alex3493]

We have a solution: custom validator.

<?php
declare(strict_types=1);

namespace App\Module\Shared\Infrastructure\Persistence\Validator;

use Symfony\Component\Validator\Constraint;

class UniqueEntityWithoutFilters extends Constraint
{
    public string|array $fields = [];

    public string $message = 'This value is already used.';

    public function getTargets(): array|string
    {
        return self::CLASS_CONSTRAINT;
    }

    public function validatedBy(): string
    {
        return \get_class($this).'Validator';
    }
}

<?php
declare(strict_types=1);

namespace App\Module\Shared\Infrastructure\Persistence\Validator;

use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;
use Symfony\Component\Validator\Validator\ValidatorInterface;

class UniqueEntityWithoutFiltersValidator extends ConstraintValidator
{
    private array $enabledFilters = [];

    public function __construct(
        private readonly EntityManagerInterface $entityManager, private readonly ValidatorInterface $validator
    ) {
    }

    /**
     * @param mixed $value
     * @param \Symfony\Component\Validator\Constraint $constraint
     * @return void
     */
    public function validate(mixed $value, Constraint $constraint): void
    {
        if (! $constraint instanceof UniqueEntityWithoutFilters) {
            throw new \InvalidArgumentException(sprintf('Expected constraint of type "%s", "%s" given.',
                UniqueEntityWithoutFilters::class, \get_class($constraint)));
        }

        // Disable filters.
        $this->disableFilters(true);

        // Create a new UniqueEntity constraint with the same properties.
        $uniqueEntityConstraint = new UniqueEntity([
            'fields' => $constraint->fields,
            'message' => $constraint->message,
            'entityClass' => $constraint->entityClass ?? \get_class($value),
        ]);

        // Validate using the validator service.
        $violations = $this->validator->validate($value, [$uniqueEntityConstraint]);

        // Add violations to the current context.
        foreach ($violations as $violation) {
            $this->context->buildViolation($violation->getMessage())->atPath($violation->getPropertyPath())
                          ->addViolation();
        }

        // Re-enable filters.
        $this->disableFilters(false);
    }

    private function disableFilters(bool $disable): void
    {
        $filters = $this->entityManager->getFilters();

        if ($disable) {
            foreach ($filters->getEnabledFilters() as $name => $filter) {
                $this->enabledFilters[] = $name;
                $filters->disable($name);
            }
        } else {
            foreach ($this->enabledFilters as $name) {
                $filters->enable($name);
            }
            $this->enabledFilters = [];
        }
    }
}

Then in services:

    App\Module\Shared\Infrastructure\Persistence\Validator\UniqueEntityWithoutFiltersValidator:
        arguments:
            $entityManager: '@doctrine.orm.entity_manager'
            $validator: '@validator'
        tags: [validator.constraint_validator]

And user validator:

App\Module\User\Domain\User:
    constraints:
        -   App\Module\Shared\Infrastructure\Persistence\Validator\UniqueEntityWithoutFilters:
                fields: email
                message: "Email is already taken"
    properties:
        email:
            -   Email: ~