New in Symfony 5.1: Reusable sets of constraints

March 13, 2020 • Published by Javier Eguiluz

Warning: This post is about an unsupported Symfony version. Some of this information may be out of date. Read the most recent Symfony Docs.

Contributed by
Maxime Steinhausser
in #34334.

In certain applications is common to reuse the same set of constraints in multiple places. Consider for example an application that allows to register users, change passwords, remember forgotten passwords, etc. That application may use different DTOs for each feature but all of them contain the new user password, which must be validated in the same way in all cases.

In Symfony 5.1, you can quickly create a validator reusing other constraints, no matter if they are built-in or custom made, thanks to the new Compound constraint:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
        namespace App\Validator;

use Symfony\Component\Validator\Constraints\Compound;
use Symfony\Component\Validator\Constraints\Length;
use Symfony\Component\Validator\Constraints\NotBlank;
use Symfony\Component\Validator\Constraints\NotCompromisedPassword;
use Symfony\Component\Validator\Constraints\Type;

/**
 * @Annotation
 */
class MatchesPasswordRequirements extends Compound
{
    protected function getConstraints(array $options): array
    {
        return [
            new NotBlank(),
            new Type('string'),
            new Length(['min' => 12]),
            new NotCompromisedPassword(),
        ];
    }
}
    

Now you can apply this constraint to your objects as usual:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
        namespace App\Dto;

// ...
use App\Validator\MatchesPasswordRequirements;

class ChangePasswordDto
{
    /**
     * @MatchesPasswordRequirements
     */
    private $newPassword;

    // ...
}
    

Validate constraints sequentially

Contributed by
Maxime Steinhausser
in #34456.

In Symfony 5.1 we also added a different, but related, feature to validate a set of constraints sequentially. This was already possible thanks to the GroupSequence constraint, but in Symfony 5.1 we simplified this feature with the introduction of a new Sequentially constraint.

The argument of the Sequentially constraint is a set of one or more constraints. Symfony will apply them in that same order and if any of them fails, it will stop and the rest of constraints won't be tested. This is useful to prevent both unexpected type exceptions thrown by some constraints and unnecessary calls to slow constraints:

        1
2
3
4
5
6
7
8
9
10
11
        /**
 * @var string
 *
 * @Assert\Sequentially({
 *     @Assert\Type("string"),
 *     @Assert\Length(min="4"),
 *     @Assert\Regex("[a-z]"),
 *     @SomeCustomConstraintWithHeavyExternalCalls(),
 * })
 */
public $someProperty;
    

Published in #Living on the edge

Help the Symfony project!

As with any Open-Source project, contributing code or documentation is the most common way to help, but we also have a wide range of sponsoring opportunities.