How to Sequentially Apply Validation Groups

Warning: You are browsing the documentation for Symfony 7.0, which is no longer maintained.

Read the updated version of this page for Symfony 7.1 (the current stable version).

In some cases, you want to validate your groups by steps. To do this, you can use the GroupSequence feature. In this case, an object defines a group sequence, which determines the order groups should be validated.

For example, suppose you have a User class and want to validate that the username and the password are different only if all other validation passes (in order to avoid multiple error messages).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// src/Entity/User.php
namespace App\Entity;

use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Validator\Constraints as Assert;

#[Assert\GroupSequence(['User', 'Strict'])]
class User implements UserInterface
{
    #[Assert\NotBlank]
    private string $username;

    #[Assert\NotBlank]
    private string $password;

    #[Assert\IsTrue(
        message: 'The password cannot match your username',
        groups: ['Strict'],
    )]
    public function isPasswordSafe(): bool
    {
        return ($this->username !== $this->password);
    }
}

In this example, it will first validate all constraints in the group User (which is the same as the Default group). Only if all constraints in that group are valid, the second group, Strict, will be validated.

Caution

As you have already seen in How to Apply only a Subset of all Your Validation Constraints (Validation Groups), the Default group and the group containing the class name (e.g. User) were identical. However, when using Group Sequences, they are no longer identical. The Default group will now reference the group sequence, instead of all constraints that do not belong to any group.

This means that you have to use the {ClassName} (e.g. User) group when specifying a group sequence. When using Default, you get an infinite recursion (as the Default group references the group sequence, which will contain the Default group which references the same group sequence, ...).

Caution

Calling validate() with a group in the sequence (Strict in previous example) will cause a validation only with that group and not with all the groups in the sequence. This is because sequence is now referred to Default group validation.

You can also define a group sequence in the validation_groups form option:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// src/Form/MyType.php
namespace App\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Validator\Constraints\GroupSequence;
// ...

class MyType extends AbstractType
{
    // ...
    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'validation_groups' => new GroupSequence(['First', 'Second']),
        ]);
    }
}

Group Sequence Providers

Imagine a User entity which can be a normal user or a premium user. When it's a premium user, some extra constraints should be added to the user entity (e.g. the credit card details). To dynamically determine which groups should be activated, you can create a Group Sequence Provider. First, create the entity and a new constraint group called Premium:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// src/Entity/User.php
namespace App\Entity;

use Symfony\Component\Validator\Constraints as Assert;

class User
{
    #[Assert\NotBlank]
    private string $name;

    #[Assert\CardScheme(
        schemes: [Assert\CardScheme::VISA],
        groups: ['Premium'],
    )]
    private string $creditCard;

    // ...
}

Now, change the User class to implement GroupSequenceProviderInterface and add the getGroupSequence(), method, which should return an array of groups to use:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// src/Entity/User.php
namespace App\Entity;

// ...
use Symfony\Component\Validator\GroupSequenceProviderInterface;

class User implements GroupSequenceProviderInterface
{
    // ...

    public function getGroupSequence(): array|GroupSequence
    {
        // when returning a simple array, if there's a violation in any group
        // the rest of the groups are not validated. E.g. if 'User' fails,
        // 'Premium' and 'Api' are not validated:
        return ['User', 'Premium', 'Api'];

        // when returning a nested array, all the groups included in each array
        // are validated. E.g. if 'User' fails, 'Premium' is also validated
        // (and you'll get its violations too) but 'Api' won't be validated:
        return [['User', 'Premium'], 'Api'];
    }
}

At last, you have to notify the Validator component that your User class provides a sequence of groups to be validated:

1
2
3
4
5
6
7
8
9
10
// src/Entity/User.php
namespace App\Entity;

// ...

#[Assert\GroupSequenceProvider]
class User implements GroupSequenceProviderInterface
{
    // ...
}

Advanced Validation Group Provider

In the previous section, you learned how to change the sequence of groups dynamically based on the state of your entity. However, in more advanced cases you might need to use some external configuration or service to define that sequence of groups.

Managing the entity initialization and manually setting its dependencies can be cumbersome, and the implementation might not align with the entity responsibilities. To solve this, you can configure the implementation of the GroupProviderInterface outside of the entity, and even register the group provider as a service.

Here's how you can achieve this:

  1. Define a Separate Group Provider Class: create a class that implements the GroupProviderInterface and handles the dynamic group sequence logic;
  2. Configure the User with the Provider: use the provider option within the GroupSequenceProvider attribute to link the entity with the provider class;
  3. Autowiring or Manual Tagging: if autowiring is enabled, your custom provider will be automatically linked. Otherwise, you must tag your service manually with the validator.group_provider tag.
1
2
3
4
5
6
7
8
9
10
11
// src/Entity/User.php
namespace App\Entity;

// ...
use App\Validator\UserGroupProvider;

#[Assert\GroupSequenceProvider(provider: UserGroupProvider::class)]
class User
{
    // ...
}

With this approach, you can maintain a clean separation between the entity structure and the group sequence logic, allowing for more advanced use cases.

How to Sequentially Apply Constraints on a Single Property

Sometimes, you may want to apply constraints sequentially on a single property. The Sequentially constraint can solve this for you in a more straightforward way than using a GroupSequence.

This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.
TOC
    Version