[Form] Add `AsFormType` attribute to create FormType directly on model classes #60563

WedgeSama · 2025-05-27T12:56:17Z

Q	A
Branch?	7.4
Bug fix?	no
New feature?	yes
Deprecations?	no
License	MIT

Form Attribute

This PR is about how to use PHP Attribute to build a Symfony Form.

Build your form directly on your data (e.g. on a DTO but not limited to it 😉).

Brainstormed with @Jean-Beru @Neirda24 and @smnandre

EDITED: !!! Disclamer !!!
This PR will not replace nor deprecate anything in the Form Component. This is just syntactic sugar 😉

Description

What in mind when starting this:

less code to build a form (a lot less!)
prevent the need to write a dedicated FormType class
Make mandatory to use object (DTO?) as data and not array (data_class mandatory but implicit)
"Data first, Form second instead of Form first, Data second" quoted from @Neirda24 😄
keep all existing features and capabilities of a classic FormType (easy because in the background, it is still a FormType 😉)

Here what it looks like with a basic example:

// UserDTO.php
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\RepeatedType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;

#[AsFormType(options: [
    // Set default option for your root FormType.
    'label' => 'FOO MAIN TITLE',
])]
class UserDTO
{
    #[Type] // Use of FormTypeGuesser to guess the right type.
    public ?string $name = null;

    #[Type(EmailType::class)]
    public ?string $email = null;

    #[Type(RepeatedType::class, [
        'type' => PasswordType::class,
    ])]
    public ?string $password = null;

    #[Type(options: [
        'label' => 'More info',
    ])]
    public ?string $info = null;

    #[Type(TextareaType::class)]
    public ?string $description = null;

    #[Type(AnotherDTO::class)] // Allow the use of others DTO directly.
    public ?AnotherDTO $another;
}

// Anywhere you nee to call your form, service, controller, etc...

$formFactory = /* get here your FromFactory */

$user = new UserDTO();
$form = $formFactory->create(UserDTO::class, $user);
// or get a FormBuilder (or call any other method of the Factory like you'll do with a classic FormType)
$formBuilder = $formFactory->createBuilder(UserDTO::class, $user);

// Then do what you need to do with your brand-new form :wink:

Basic features (implemented in this PR)

Basic form

| - With Attributes

namespace App\DTO;

use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\RepeatedType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;

#[AsFormType(options: [
    'label' => 'FOO MAIN TITLE',
])]
class UserDTO
{
    #[Type]
    public string $name;

    #[Type(EmailType::class)]
    public string $email;

    #[Type(RepeatedType::class, [
        'type' => PasswordType::class,
    ])]
    public string $password;

    #[Type(options: [
        'label' => 'More info',
    ])]
    public string $info;

    #[Type(type: TextareaType::class)]
    public string $description;
}

namespace App\Controller;

use App\DTO\UserDTO;

class HomeController extends AbstractController
{
    #[Route('/', name: 'app_home')]
    public function index(): Response
    {
        // Same `createForm` method for existing form.
        $form = $this->createForm(UserDTO::class);
        // ...
    }
}

| - Classic equivalence (without attribute)

namespace App\DTO;

class UserDTO
{
    public string $name;
    public string $email;
    public string $password;
    public string $info;
    public string $description;
}

namespace App\Controller;

use App\Form\UserDTOType;

class HomeController extends AbstractController
{
    #[Route('/', name: 'app_home')]
    public function index(): Response
    {
        $form = $this->createForm(UserDTOType::class);
        // ...
    }
}

namespace App\Form;

use App\DTO\UserDTO;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\EmailType;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\RepeatedType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class UserDTOType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('name')
            ->add('email', EmailType::class)
            ->add('password', RepeatedType::class, [
                'type' => PasswordType::class,
            ])
            ->add('info', null, [
                'label' => 'More info',
            ])
            ->add('description', TextareaType::class)
        ;
    }
    
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => UserDTO::class;
        ]);
    }
}

| - Variant 1, with one attribute per FormType (Not implemented)

Thought of that too, I like the readability but maybe too much work to maintain.

Still need a 'GenericType' to work with type that does not have attribute equivalence.

namespace App\DTO;

use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;

#[AsFormType]
class UserDTO
{
    #[Type\TextType]
    public string $name;

    #[Type\EmailType]
    public string $email;

    #[Type\RepeatedType(options: [
        'type' => PasswordType::class,
    ])]
    public string $password;

    #[Type\TextType(options: [
        'label' => 'More info',
    ])]
    public string $info;

    // Still got a Generic type
    #[Type\FormType(type: TextareaType::class)]
    public string $description;
}

With validation

Work like a charm, without to do anything more to support it

namespace App\DTO;

use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\RepeatedType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
use Symfony\Component\Validator\Constraints as Assert;

#[AsFormType]
class UserDTO
{
    #[Type]
    #[Assert\NotBlank]
    public string $name;

    #[Type(EmailType::class)]
    #[Assert\NotBlank]
    #[Assert\Email]
    public ?string $email;

    #[Type(RepeatedType::class, [
        'type' => PasswordType::class,
    ])]
    public string $password;

    #[Type(options: [
        'label' => 'More info',
    ])]
    #[Assert\Length(min: 5, max: 511)]
    public string $info;

    #[Type(type: TextareaType::class)]
    #[Assert\Length(min: 5, max: 511)]
    public string $description;
}

Class inheritance

| - With attribute

// ParentDTO.php

#[AsFormType]
class ParentDTO
{
    #[Type]
    public string $name;
}

// ChildDTO.php

#[AsFormType]
class ChildDTO extends ParentDTO
{
    #[Type]
    public string $anotherProp;
}

| - Classic equivalence (without attribute)

// ParentDTO.php

class ParentDTO
{
    public string $name;
}

// ChildDTO.php

class ChildDTO extends ParentDTO
{
    public string $anotherProp;
}

// ParentType.php

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class ParentType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('name');
    }
    
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => ParentDTO::class;
        ]);
    }
}

// ChildType.php

class ChildType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('anotherProp');
    }
    
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => ChildDTO::class;
        ]);
    }
    public function getParent(): string
    {
        return ParentType::class;
    }
}

Next features (WIP)

Here some DX example of how to implement next features from form component with attributes.

For Form Event and Data Transformer, can be more powerful with PHP 8.5 closures_in_const_expr in the future \o/

Form Event

| - Event on the root FormType

| - With Attributes

namespace App\DTO;

use Symfony\Component\Form\Attribute\ApplyFormEvent;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\Form\FormEvents;

#[AsFormType]
#[ApplyFormEvent]
class UserDTO
{
    #[Type]
    public string $name;

    public static function onPreSetData(FormEvent $event): void
    {
        // Do stuff
    }

    #[ApplyFormEvent(FormEvents::POST_SET_DATA)]
    public static function anotherMethod(FormEvent $event): void
    {
        // Do stuff
    }
}

| - Classic equivalence (without attribute)

namespace App\DTO;

class UserDTO
{
    public string $name;
}

namespace App\Form;

use App\DTO\UserDTO;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\Form\FormEvents;
use Symfony\Component\OptionsResolver\OptionsResolver;

class UserDTOType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('name');
        
        $builder->addEventListener(FormEvents::PRE_SET_DATA, function (FormEvent $event): void {
            // Do stuff
        });
        
        $builder->addEventListener(FormEvents::POST_SET_DATA, function (FormEvent $event): void {
            // Do stuff
        });
    }
    
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => UserDTO::class;
        ]);
    }
}

| - Event on a FormType's field

| - With Attributes

namespace App\DTO;

use Symfony\Component\Form\Attribute\ApplyFormEvent;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\Form\FormEvents;

#[AsFormType]
class UserDTO
{
    #[Type]
    #[ApplyFormEvent(FormEvents::PRE_SET_DATA, 'myStaticMethod')]
//    #[ApplyFormEvent(FormEvents::PRE_SET_DATA, [AnotherClass::class, 'myStaticMethod'])] // Maybe callable too?
    public string $name;

    public static function myStaticMethod(FormEvent $event): void
    {
        // Do stuff
    }
}

| - Classic equivalence (without attribute)

namespace App\DTO;

class UserDTO
{
    public string $name;
}

namespace App\Form;

use App\DTO\UserDTO;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\Form\FormEvents;
use Symfony\Component\OptionsResolver\OptionsResolver;

class UserDTOType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('name');
        
        $builder->get('add')->addEventListener(FormEvents::PRE_SET_DATA, function (FormEvent $event): void {
            // Do stuff
        });
    }
    
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => UserDTO::class;
        ]);
    }
}

Data Transformer

| - DT on the root FormType

| - With attribute

namespace App\DTO;

use Symfony\Component\Form\Attribute\ApplyDataTransformer;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;

#[AsFormType]
#[ApplyDataTransformer(new MyTransformer())] // `model` by default?
//#[ApplyDataTransformer(new MyTransformer(), 'view')]
class UserDTO
{
    #[Type]
    public string $name;
}

| - Classic equivalence (without attribute)

namespace App\DTO;

class UserDTO
{
    public string $name;
}

namespace App\Form;

use App\DTO\UserDTO;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class UserDTOType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->addModelTransformer(new MyTransformer());
//        $builder->addViewTransformer(new MyTransformer());
        $builder->add('name');
    }
    
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => UserDTO::class;
        ]);
    }
}

| - DT on a FormType's field

| - With attribute

namespace App\DTO;

use Symfony\Component\Form\Attribute\ApplyDataTransformer;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;

#[AsFormType]
class UserDTO
{
    #[Type]
    #[ApplyDataTransformer(new MyTransformer())] // `model` by default?
//    #[ApplyDataTransformer(new MyTransformer(), 'view')]
    public string $name;
}

| - Classic equivalence (without attribute)

namespace App\DTO;

class UserDTO
{
    public string $name;
}

namespace App\Form;

use App\DTO\UserDTO;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class UserDTOType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('name');
        $builder->get('name')->addModelTransformer(new MyTransformer())
//        $builder->get('name')->addViewTransformer(new MyTransformer())
        ;
    }
    
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => UserDTO::class;
        ]);
    }
}

| - Variant 1 with DataTransformerInterface

Not a fan but.

namespace App\DTO;

use Symfony\Component\Form\Attribute\ApplyDataTransformer;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\DataTransformerInterface;

#[AsFormType]
#[ApplyDataTransformer]
//#[ApplyDataTransformer(type: 'view')]
class UserDTO implements DataTransformerInterface
{
    #[Type]
    public string $name;

    public function transform(mixed $value): mixed {}
    public function reverseTransform(mixed $value): mixed {}
}

| - Variant 2, with 2 attributes

Use 2 distinct attribute, one for model transformer, another for view transformer.

namespace App\DTO;

use Symfony\Component\Form\Attribute\ApplyModelTransformer;
use Symfony\Component\Form\Attribute\ApplyViewTransformer;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\DataTransformerInterface;

#[AsFormType]
#[ApplyModelTransformer]
//#[ApplyViewTransformer]
class UserDTO
{
    #[Type]
    public string $name;
}

Form Type Extension

namespace App\Form\Extension;

use Symfony\Component\Form\AbstractTypeExtension;
use Symfony\Component\Form\FormBuilderInterface;

class UserDTOExtension extends AbstractTypeExtension
{
    public static function getExtendedTypes(): iterable
    {
        yield UserDTO::class;
    }

    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        // do stuff, like add mapped false fields.
    }
}

Auto Form \o/

namespace App\DTO;

use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Exclude;

#[AsFormType(auto: true)]
class UserDTO
{
    public string $name;
    public string $email;
    public string $password;
    public AnotherDTO $another;

    #[Exclude]
    public string $description;
}

Need to be discussed / Possible evolution

Here stuff that I am no satisfy for now and need to be discuss to find a better way to do it.

Autowire

| - In options

namespace App\DTO;

use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;

#[AsFormType(options: [
    'label' => new Autowire(param: 'the_foo'),
])]
class UserDTO
{
    #[Type]
    public string $name;
    
    #[Type(ChoiceType::class, options: [
        'choice_loader' => new Autowire(service: MyChoiceLoader::class),
        'multiple' => true,
    ])]
    public array $tags = [];

    #[Type(ChoiceType::class, options: [
        'choice_loader' => new Autowire(expression: 'service("App\\Form\\ChoiceLoader\\TypeLoader")'),
//        'choice_label' => new Expression('choice.getIcon()'),
        'choice_label' => [new Autowire(service: MyChoiceLoader::class), 'choiceLabel'],
    ])]
    public string $type;
}

| - Event

namespace App\DTO;

use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\Form\Attribute\ApplyFormEvent;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\FormEvents;

#[AsFormType]
#[ApplyFormEvent(FormEvents::PRE_SET_DATA, new Autowire(service: MyChoiceLoader::class))]
class UserDTO
{
    #[Type]
    #[ApplyFormEvent(FormEvents::POST_SET_DATA, new Autowire(service: MyChoiceLoader::class))]
    public string $name;
}

| - Data Transformer

namespace App\DTO;

use Symfony\Component\Form\Attribute\ApplyDataTransformer;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;

#[AsFormType]
#[ApplyDataTransformer(new Autowire(service: MyTransformer::class))]
class UserDTO
{
    #[Type]
    #[ApplyDataTransformer(new Autowire(service: MyTransformer::class))]
    public string $name;
}

configureOption method

| - Varaint 1 (not fan of it)

namespace App\DTO;

use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\OptionsResolver\OptionsResolver;

#[AsFormType]
class UserDTO
{
    public string $name;
    
    public static function configureOptions(OptionsResolver $resolver): void
    {
        // Do stuff
    }
}

| - Varaint 2 (love it but PHP 8.5)

namespace App\DTO;

use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\OptionsResolver\OptionsResolver;

#[AsFormType(configureOptions: static function (OptionsResolver $resolver): void {
    // Do stuff
})]
class UserDTO
{
    public string $name;
}

Override getParent

Not sure if this means something, maybe not needed. What do you think?

namespace App\DTO;

use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\OptionsResolver\OptionsResolver;

#[AsFormType(parent: AnotherFormType::class)]
class UserDTO
{
    public string $name;
}

`Symfony Demo Application` with Form Attribute

You can try the basic examples of AsFormType in the Symfony Demo Application fork:
https://github.com/WedgeSama/demo-with-form-attribute/tree/demo-with-form-attribute

List of FormType replaced (examples on both DTO and entities):

Form\ChangePasswordType => created DTO DTO\UserChangePasswordDTO
Form\UserType => created DTO DTO\UserProfileDTO
Form\CommentType => on existing entity Entity\Comment
Form\PostType => on existing entity Entity\Post

It use git submodule to require the form component with form attribute.

PS: any suggestion are welcome 😉

carsonbot · 2025-05-27T12:56:25Z

It looks like you unchecked the "Allow edits from maintainer" box. That is fine, but please note that if you have multiple commits, you'll need to squash your commits into one before this can be merged. Or, you can check the "Allow edits from maintainers" box and the maintainer can squash for you.

Cheers!

Carsonbot

src/Symfony/Component/Form/FormTypeInterface.php

src/Symfony/Component/Form/FormRegistry.php

src/Symfony/Component/Form/Metadata/Loader/AttributeLoader.php

src/Symfony/Component/Form/Tests/DependencyInjection/FormPassTest.php

Tiriel · 2025-05-28T09:34:37Z

I do like the feature, but thinking about an extreme example of going all-in on attributes, I wonder were it goes.

Small simple example of building an app where we store informations about Events sent by users with our own schema, and we also receive informations from APIs with their own structure (you see where this is going). So we need the usual ORM attributes, some Validation, Object-Mapper, and these Form attributes. The entity becomes quite heavy on attributes.

use App\Dto\Event as EventDTO;
use App\Repository\EventRepository;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\Extension\Core\Type as FormType;
use Symfony\Component\ObjectMapper\Attribute\Map;
use Symfony\Component\Validator\Constraints as Assert;

#[AsFormType]
#[Map(target: EventDTO::class)]
#[ORM\Entity(repositoryClass: EventRepository::class)]
class Event
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;


    #[Map(target: 'eventName')]
    #[Assert\Length(min: 15)]
    #[Assert\NotBlank()]
    #[ORM\Column(length: 255)]
    #[Type]
    private ?string $name = null;

    #[Map(target: 'synopsis')]
    #[Assert\NotBlank()]
    #[ORM\Column(type: Types::TEXT)]
    #[Type(FormType\TextareaType::class)]
    private ?string $description = null;

    // ...

As you can see, the business need is small, there's not much in terms of validation or mapping, and I've included only few properties.

I don't know if that's a problem honestly, it's not that unreadable to me, by I do think the question should be raised.

That being said, once again, this is a really nice and neat feature, great job!

Neirda24 · 2025-05-28T10:06:57Z

I do like the feature, but thinking about an extreme example of going all-in on attributes, I wonder were it goes.

Small simple example of building an app where we store informations about Events sent by users with our own schema, and we also receive informations from APIs with their own structure (you see where this is going). So we need the usual ORM attributes, some Validation, Object-Mapper, and these Form attributes. The entity becomes quite heavy on attributes.
use App\Dto\Event as EventDTO;
use App\Repository\EventRepository;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Form\Attribute\AsFormType;
use Symfony\Component\Form\Attribute\Type;
use Symfony\Component\Form\Extension\Core\Type as FormType;
use Symfony\Component\ObjectMapper\Attribute\Map;
use Symfony\Component\Validator\Constraints as Assert;

#[AsFormType]
#[Map(target: EventDTO::class)]
#[ORM\Entity(repositoryClass: EventRepository::class)]
class Event
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;


    #[Map(target: 'eventName')]
    #[Assert\Length(min: 15)]
    #[Assert\NotBlank()]
    #[ORM\Column(length: 255)]
    #[Type]
    private ?string $name = null;

    #[Map(target: 'synopsis')]
    #[Assert\NotBlank()]
    #[ORM\Column(type: Types::TEXT)]
    #[Type(FormType\TextareaType::class)]
    private ?string $description = null;

    // ...
As you can see, the business need is small, there's not much in terms of validation or mapping, and I've included only few properties.

I don't know if that's a problem honestly, it's not that unreadable to me, by I do think the question should be raised.

That being said, once again, this is a really nice and neat feature, great job!

I think in your usecase if you map object to a dto then the form should probably be on said dto. WDYT ?

Tiriel · 2025-05-28T10:29:03Z

I think in your usecase if you map object to a dto then the form should probably be on said dto. WDYT ?

I know you love teasing me 😉 . Just to keep you happy:

It's a fictitious example made just for testing
In this case the DTO is intended to receive data from an API and allow mapping to the entity, when the entity is the base for the frontend form.

I don't pretend this usecase is universale though. Once again, it's designed to create a fake extreme example, to show what it could lead. It's more of a "let's pretend there's a need like that".

And then again, I don't say I'm definitely against this, I love the feature. But I also like to raise questions ;)

yceruto · 2025-05-28T11:53:07Z

This look like a fantastic addition for simple forms, but honestly I'm not 100% sure for mid-level and complex forms.

PHP attributes are excellent for declaratively adding metadata, but there are limitations and cases where attributes are not the best fit. For instance, dynamic field definition, custom business logic, injecting services, or conditional configuration. In those cases, the traditional FormType classes may still be preferable (as they are services by definition).

I don’t think we should replicate all form type capabilities with attributes (because the scope and dynamic limitations), but they can certainly be useful for building simple forms quickly, and then easily switch to FormType classes when things get more complex.

Neirda24 · 2025-05-28T12:50:30Z

@yceruto : Yes this is a totally valid point. I don't think attributes are meant to replace Forms. But should try to cover most common cases without the need to refactor it to a dedicated class. Might be worth adding a warning to the documentation of this feature the list of known limitations.

yceruto · 2025-05-28T13:53:34Z

$form = $formFactory->create(UserDTO::class, $user);

It looks strange from the design PoV passing the DTO class as form type. I’m wondering if, instead of passing the data class, we can leave the form type param as null and let the type be guessed from the data (if AsFormType)?

$form = $formFactory->create(null, $user); // the form type will be guessed and defined from the DTO

Maybe the same guesser mechanism could help with this? It'd be aligned with the null form type concept.

WedgeSama · 2025-05-28T14:15:01Z

@Tiriel Yes it can be used directly on entities, but even with your example, to make it more readable, a dedicated DTO for the form can still be done 😉

@yceruto I think its a good start to keep it simple yes. We just need to set the limit to which capabilities we want to replicate. I also thought of a command that can "convert" an attribute form to a traditional FormType, something like make:form:from-metadata. WDYT?

And Im totally agree to something like :

$form = $formFactory->create(null, $user);
// or even?
$form = $formFactory->create($user);

yceruto · 2025-05-28T14:14:25Z

src/Symfony/Component/Form/Attribute/Type.php

+ * @author Benjamin Georgeault <git@wedgesama.fr>
+ */
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final readonly class Type


To stay consistent with the purpose of this attribute, as described in the class description, it represents a form field, so I’d prefer to name this class Field ?

I think Field is wrong. Because it's biased by how it displays. But a "Field" could be an entire form. so I think we should keep Type but maybe rename other occurences of Field's to Type's. WDYT ?

Maybe a description like this is more clear and accurate:

* Can be added to class property, in cases where the class is marked with {@see AsFormType} attribute. * It defines a field for this form type (can by a nested group of fields too).

IMHO, the term field in the description is still ok. If you take a look at FormBuilderInterface::add description, the same word is used to describe it.

And agreed with @Neirda24 to keep it Type as class' name.

@yceruto Any thought?

src/Symfony/Component/Form/Attribute/Type.php

Tiriel · 2025-05-28T14:21:39Z

@Tiriel Yes it can be used directly on entities, but even with your example, to make it more readable, a dedicated DTO for the form can still be done 😉

In that case, what would be the benefit of using a new dedicated DTO+ attribute over a regular FormType class?

yceruto · 2025-05-28T14:39:18Z

I think its a good start to keep it simple yes. We just need to set the limit to which capabilities we want to replicate.

There are implicit limitations with options and Closures, which may be mitigated in PHP 8.5, but still, adding large blocks of logic in attributes feels a bit messy to me.

I think advanced features like data mappers, form events, and model/view transformers carry special complexity and responsibility tied to the form type itself, but I’m open to making them configurable using attributes, as long as we can also implement them outside the DTO.

yceruto · 2025-05-28T14:39:30Z

I also thought of a command that can "convert" an attribute form to a traditional FormType, something like make:form:from-metadata. WDYT?

Yes, but what about just creating a command that generate the form type from a DTO 😅?
It's already possible from an Entity class https://github.com/symfony/maker-bundle/blob/1.x/src/Maker/MakeForm.php

yceruto · 2025-05-28T14:39:50Z

And Im totally agree to something like :
$form = $formFactory->create(null, $user);
// or even?
$form = $formFactory->create($user);

even $form = $formFactory->create(data: $user) is fine currently

src/Symfony/Component/Form/Tests/Extension/Metadata/Type/MetadataTypeTest.php

Neirda24 · 2025-05-28T14:45:33Z

And Im totally agree to something like :
$form = $formFactory->create(null, $user);
// or even?
$form = $formFactory->create($user);

even $form = $formFactory->create(data: $user) is fine currently

Symfony does not guarantee named arguments on methods at the moment. So maybe better not show this on documentation / example ?

WedgeSama · 2025-05-28T15:23:03Z

@Tiriel Still one class less, less code:

Traditional (with DTO): Entity + DTO + FormType
Attributes (with DTO) : Entity + DTO

@yceruto

which may be mitigated in PHP 8.5

Yes, using the closure inside attributes in 8.5 can remove some limitations.

I think advanced features like data mappers, form events, and model/view transformers carry special complexity and responsibility tied to the form type itself, but I’m open to making them configurable using attributes, as long as we can also implement them outside the DTO.

Agreed

Yes, but what about just creating a command that generate the form type from a DTO 😅?

Can still be done, those 2 features are not mutually exclusive 😄

Tiriel · 2025-05-28T17:31:25Z

@Tiriel Still one class less, less code:

Traditional (with DTO): Entity + DTO + FormType

Attributes (with DTO) : Entity + DTO

I don't think we're talking about the same thing and we're going deep into things not strictly related to this feature. I don't see the point of the DTO in the first traditional case. And so, the number of classes is the same.

But that's beside the point. I'm not against you or the feature, I'm just saying that there are use cases where this could lead to bloated entities. And I'm not sure that advising user to put the attributes on another unnecessary class is the best solution.

But then again I seem to be the only one fearing that so maybe it's not that much of a concern.

GromNaN

I am very enthusiastic about this feature after seeing your slides: https://speakerdeck.com/wedgesama/symfonyonline-june-2025-simplify-your-symfony-form-with-php8-attributes

I have noticed some improvements in integration with the framework.

There is a topic on reading attributes, which is better done at compilation rather than at runtime. However, this restrict the use of closures in attributes (for event listeners).

src/Symfony/Component/Form/FormTypeInterface.php

src/Symfony/Bundle/FrameworkBundle/DependencyInjection/FrameworkExtension.php

GromNaN · 2025-06-18T11:56:44Z

src/Symfony/Bundle/FrameworkBundle/DependencyInjection/FrameworkExtension.php

            $container->setParameter('form.type_extension.csrf.enabled', false);
        }

+        if ($config['form']['use_attribute']) {


Using attributes is already opt-in as you have to add the attribute to a class that is autoconfigured. I understand the benefit of this new configuration in avoiding the declaration of unnecessary services, but it would be simpler for users of the framework if they did not need to activate this option.
Unnecessary service (form.metadata.attribute_loader) can be removed in the compiler pass.

Maybe switch to enable by default instead of disable by default in src/Symfony/Bundle/FrameworkBundle/DependencyInjection/Configuration.php to keep the possibility to disable, WDYF?

If no form.metadata.form_type tags exist, the services in the CompilerPass can be removed, eliminating the need for the use_attribute configuration.

src/Symfony/Component/Form/DependencyInjection/FormPass.php

src/Symfony/Component/Form/Metadata/Loader/AttributeLoader.php

src/Symfony/Component/Form/Attribute/AsFormType.php

src/Symfony/Component/Form/Extension/DataCollector/FormDataExtractor.php

stof · 2025-09-18T11:48:32Z

src/Symfony/Component/Form/Attribute/AsFormType.php

+ * @author Benjamin Georgeault <git@wedgesama.fr>
+ */
+#[\Attribute(\Attribute::TARGET_CLASS)]
+class AsFormType


I don't like the name AsFormType as it looks like it will register the service as a form type (tagging it as form.type), while it has a totally different behavior (it defines that class as providing metadata to configure a form type, not as being a form type)

What do you think of:

AsFormMetadata

FormMetadata

AsForm

I have a preference for the 1. And if you have ideas 🙏

IMO even if it is not a Form type per se, it is used as a form type. same goes for AsController. It marks the class a controller when in fact it is the methods

@stof WDYT of answers?

webda2l · 2025-10-07T19:46:24Z

Nice, but I remain skeptical about replicating all the form features (currently your WIP Form Event & Data Transformer) directly in the class object. Even if this new approach is optional, there’s a significant risk it could lead to messy code for some users, IMO.
For my specific needs (auto fields and embedded forms for objects/collections) I’m working on an alternative: a2lix/AutoFormBundle (draft branch). It’s a hybrid solution that combines Form and attribute-based configuration, with the goal of minimizing modifications to the entity/DTO. This way, we keep things clean and flexible by default, while still allowing overrides when needed.

…l classes

webda2l · 2025-12-12T10:45:41Z

Nice, but I remain skeptical about replicating all the form features (currently your WIP Form Event & Data Transformer) directly in the class object. Even if this new approach is optional, there’s a significant risk it could lead to messy code for some users, IMO. For my specific needs (auto fields and embedded forms for objects/collections) I’m working on an alternative: a2lix/AutoFormBundle (draft branch). It’s a hybrid solution that combines Form and attribute-based configuration, with the goal of minimizing modifications to the entity/DTO. This way, we keep things clean and flexible by default, while still allowing overrides when needed.

For those interested in this feature, I’ve released my alternative implementation with the v1 of AutoFormBundle (and optionally v4 of TranslationFormBundle to automatically handle Gedmo/Knp translation cases).

WedgeSama requested review from xabbuh and yceruto as code owners May 27, 2025 12:56

carsonbot added Status: Needs Review Feature Form labels May 27, 2025

carsonbot added this to the 7.4 milestone May 27, 2025

WedgeSama force-pushed the form-attribute branch 3 times, most recently from 82ed4dc to 2cfe438 Compare May 28, 2025 06:10

OskarStark mentioned this pull request May 28, 2025

Remove/hide comment, after change symfony-tools/carsonbot#271

Open

Neirda24 reviewed May 28, 2025

View reviewed changes

WedgeSama force-pushed the form-attribute branch 2 times, most recently from 884ad5e to 2eb6ef0 Compare May 28, 2025 07:03

yceruto reviewed May 28, 2025

View reviewed changes

Jean-Beru reviewed May 28, 2025

View reviewed changes

src/Symfony/Component/Form/Tests/Extension/Metadata/Type/MetadataTypeTest.php Outdated Show resolved Hide resolved

src/Symfony/Component/Form/Tests/Extension/Metadata/Type/MetadataTypeTest.php Outdated Show resolved Hide resolved

GromNaN reviewed Jun 18, 2025

View reviewed changes

WedgeSama force-pushed the form-attribute branch 4 times, most recently from 2348039 to 484bc0a Compare July 7, 2025 06:26

WedgeSama force-pushed the form-attribute branch 4 times, most recently from 626fd87 to 0ccc73f Compare September 18, 2025 10:04

stof reviewed Sep 18, 2025

View reviewed changes

WedgeSama force-pushed the form-attribute branch 7 times, most recently from ef9388c to 59f0ab8 Compare October 1, 2025 13:11

welcoMattic added the ❄️ Feature Freeze Important Pull Requests to finish before the next Symfony "feature freeze" label Oct 7, 2025

WedgeSama requested review from GromNaN, stof and yceruto October 7, 2025 15:15

nicolas-grekas removed the ❄️ Feature Freeze Important Pull Requests to finish before the next Symfony "feature freeze" label Oct 24, 2025

nicolas-grekas modified the milestones: 7.4, 8.1 Nov 16, 2025

WedgeSama force-pushed the form-attribute branch 2 times, most recently from 136c4ee to a79a967 Compare December 4, 2025 10:44

[Form] Add AsFormType attribute to create FormType directly on mode…

c3c026f

…l classes

WedgeSama force-pushed the form-attribute branch from a79a967 to c3c026f Compare December 4, 2025 10:51

Uh oh!

[Form] Add AsFormType attribute to create FormType directly on model classes #60563

Are you sure you want to change the base?

[Form] Add AsFormType attribute to create FormType directly on model classes #60563

Conversation

WedgeSama commented May 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Form Attribute

Description

Basic features (implemented in this PR)

Next features (WIP)

Need to be discussed / Possible evolution

Symfony Demo Application with Form Attribute

Uh oh!

carsonbot commented May 27, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Tiriel commented May 28, 2025

Uh oh!

Neirda24 commented May 28, 2025

Uh oh!

Tiriel commented May 28, 2025

Uh oh!

yceruto commented May 28, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Neirda24 commented May 28, 2025

Uh oh!

yceruto commented May 28, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

WedgeSama commented May 28, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

WedgeSama Jun 2, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Tiriel commented May 28, 2025

Uh oh!

yceruto commented May 28, 2025

Uh oh!

yceruto commented May 28, 2025

Uh oh!

yceruto commented May 28, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Neirda24 commented May 28, 2025

Uh oh!

WedgeSama commented May 28, 2025

Uh oh!

Tiriel commented May 28, 2025

Uh oh!

GromNaN left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

[Form] Add `AsFormType` attribute to create FormType directly on model classes #60563

[Form] Add `AsFormType` attribute to create FormType directly on model classes #60563

WedgeSama commented May 27, 2025 •

edited

Loading

`Symfony Demo Application` with Form Attribute

yceruto commented May 28, 2025 •

edited

Loading

yceruto commented May 28, 2025 •

edited

Loading

WedgeSama Jun 2, 2025 •

edited

Loading

yceruto commented May 28, 2025 •

edited

Loading

WedgeSama Sep 29, 2025 •

edited

Loading