Symfony Form Handler Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require ardenexal/symfony-form-handler
   

   (Note: Due to archival status, verify compatibility with your Symfony/Laravel environment via symfony/form and symfony/validator constraints.)

2. Register the Bundle Add to config/bundles.php (Symfony) or manually bootstrap in Laravel via a service provider:

   // app/Providers/AppServiceProvider.php (Laravel)
   public function register()
   {
       $this->app->register(\Ardenexal\FormHandlerBundle\FormHandlerBundle::class);
   }
   

3. First Use Case Create a form handler for a simple contact form:

   // src/Form/ContactFormHandler.php
   use Ardenexal\FormHandlerBundle\Form\FormHandlerInterface;
   
   class ContactFormHandler implements FormHandlerInterface
   {
       public function handle(array $data)
       {
           // Process data (e.g., save to DB, send email)
           return ['success' => true];
       }
   }
   

4. Controller Integration

   // src/Controller/ContactController.php
   use Symfony\Component\HttpFoundation\Request;
   use Symfony\Component\HttpFoundation\Response;
   use Ardenexal\FormHandlerBundle\Form\FormHandler;
   
   class ContactController
   {
       public function submit(Request $request, FormHandler $handler): Response
       {
           $data = $request->request->all();
           $result = $handler->handle($data, ContactFormHandler::class);
           return new Response(json_encode($result));
       }
   }
   

Implementation Patterns

Core Workflows

1. Form Handler Lifecycle

   • Validation: Automatically validates against Symfony’s ValidatorInterface if a FormType is associated.
   • Processing: Execute custom logic in handle() (e.g., entity persistence, API calls).
   • Response: Return structured data (e.g., ['success' => true, 'message' => '...']).

2. Dependency Injection Bind handlers as services for testability:

   # config/services.yaml (Symfony)
   services:
       App\Form\ContactFormHandler:
           tags: ['ardenexal.form_handler']
   

3. Form Integration Pair with Symfony’s FormType for validation:

   // src/Form/ContactType.php
   class ContactType extends AbstractType
   {
       public function buildForm(FormBuilderInterface $builder, array $options)
       {
           $builder->add('name', TextType::class);
           $builder->add('email', EmailType::class);
       }
   }
   

   // In handler
   public function handle(array $data)
   {
       $form = $this->createForm(ContactType::class, null, ['data' => $data]);
       if (!$form->isValid()) {
           return ['errors' => $form->getErrors(true)];
       }
       // Proceed...
   }
   

4. Laravel Adaptation

   • Use Symfony\Component\Form\FormFactory via Laravel’s Symfony bridge:

     $factory = $this->app->make('form.factory');
     $form = $factory->createNamedBuilder('contact', ContactType::class, null, ['data' => $data]);
     

   • Wrap handler logic in a Laravel service and inject via controller.

Gotchas and Tips

Pitfalls

1. Archival Status

   • Risk: No updates since 2020; may conflict with modern Symfony/Laravel versions.
   • Mitigation: Fork the repo or use a similar package like symfony/form directly.

2. Validation Overhead

   • Issue: Manual validation in handle() bypasses Symfony’s built-in form validation.
   • Fix: Use FormHandlerInterface::validate() if available, or integrate ValidatorInterface:

     $errors = $this->validator->validate($data, new ContactConstraints());
     

3. Laravel Compatibility

   • Challenge: Bundle assumes Symfony’s Request/Response; Laravel uses its own stack.
   • Workaround: Normalize requests/responses in a wrapper class:

     $data = request()->all(); // Laravel
     $response = response()->json($result); // Laravel
     

Debugging Tips

1. Handler Not Found

   • Ensure the handler class is tagged as a service (Symfony) or manually registered (Laravel).
   • Check for typos in the handler class name passed to FormHandler.

2. Validation Errors

   • Dump $form->getErrors(true) to inspect constraints:

     dd($form->getErrors(true)->getChildren());
     

3. Performance

   • Avoid heavy operations in handle(); offload to services (e.g., MessageBus for emails).

Extension Points

1. Custom Handlers Extend FormHandlerInterface to add pre/post-processing:

   class CustomFormHandler implements FormHandlerInterface
   {
       public function handle(array $data)
       {
           $this->preProcess($data);
           $result = parent::handle($data);
           $this->postProcess($result);
           return $result;
       }
   }
   

2. Event Listeners Attach listeners to FormHandlerEvents (if supported) for cross-cutting concerns:

   $dispatcher->addListener('form.handler.process', function ($event) {
       // Log, audit, etc.
   });
   

3. Testing Mock FormHandler in PHPUnit:

   $handler = $this->createMock(FormHandler::class);
   $handler->method('handle')->willReturn(['success' => true]);