Symfony Export Laravel Package

Getting Started

Minimal Setup in Laravel

1. Installation

   composer require denisok94/symfony-export
   

   (Note: This is a Symfony package—Laravel integration requires manual adaptation via Symfony’s HttpFoundation or a facade wrapper.)

2. First Use Case: CSV Export

   use Symfony\Component\HttpFoundation\ResponseHeaderBag;
   use Symfony\Component\HttpFoundation\StreamedResponse;
   
   // Sample data (replace with Eloquent query or collection)
   $data = [
       ['id' => 1, 'name' => 'John'],
       ['id' => 2, 'name' => 'Jane'],
   ];
   
   // Stream CSV response
   $response = new StreamedResponse(
       fn() => \Symfony\Component\Serializer\Serializer::encode(
           $data,
           'csv',
           ['headers' => ['id', 'name']]
       ),
       200,
       ['Content-Type' => 'text/csv']
   );
   
   $response->setContentDisposition(
       ResponseHeaderBag::DISPOSITION_ATTACHMENT,
       'export.csv'
   );
   
   return $response;
   

3. Where to Look First

   • Symfony Docs: Serializer Component (core for export logic).
   • Package Source: src/Serializer/Encoder/CsvEncoder.php (custom encoder if needed).
   • Laravel Wrapper: Check for community forks (e.g., spatie/laravel-export) for tighter integration.

Implementation Patterns

1. Data Transformation Workflows

• Normalize Eloquent Collections:

  use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
  
  $normalizer = new ObjectNormalizer();
  $normalized = $normalizer->normalize($users->toArray(), null, [
      'ignored_attributes' => ['pivot', 'timestamps'],
      'callbacks' => [
          'name' => fn($name) => ucfirst($name),
      ],
  ]);
  

• Custom Encoders: Extend CsvEncoder for complex formats (e.g., nested arrays → tab-separated).

2. Integration with Laravel

• Middleware for Export Routes:

  // app/Http/Middleware/ExportMiddleware.php
  public function handle($request, Closure $next) {
      if ($request->wantsJson() && $request->has('export')) {
          return $this->export($request);
      }
      return $next($request);
  }
  

• Service Class:

  // app/Services/ExportService.php
  public function toCsv($data, string $filename) {
      $serializer = new Serializer([new ObjectNormalizer()], [new CsvEncoder()]);
      $csv = $serializer->serialize($data, 'csv');
      return response($csv, 200)->header('Content-Disposition', "attachment; filename=$filename");
  }
  

3. Batch Processing

• Chunked Exports (for large datasets):

  $chunkSize = 1000;
  $users->chunk($chunkSize, function ($chunk) use ($response) {
      $csv = (new Serializer())->serialize($chunk, 'csv');
      $response->write($csv);
  });
  $response->send();
  

4. API-Driven Exports

• Accept Headers:

  if ($request->header('Accept') === 'text/csv') {
      return $this->exportService->toCsv($data, 'report.csv');
  }
  

Gotchas and Tips

Pitfalls

1. Symfony Dependencies:

   • Missing symfony/http-foundation or symfony/serializer will break the package. Install via Composer:

     composer require symfony/http-foundation symfony/serializer
     

   • Laravel 10+: Use symfony:^6.0 for compatibility.

2. CSV Encoding Issues:

   • BOM (Byte Order Mark): Add ['headers' => ['\xEF\xBB\xBF' . 'id', 'name']] to force UTF-8.
   • Special Characters: Escape with ['csv_encoding' => 'UTF-8', 'csv_escape' => '"'].

3. Memory Limits:

   • Large datasets may hit Allowed memory size exhausted. Use StreamedResponse (as shown above) or chunk data.

4. No Built-in Laravel Facade:

   • The package lacks Laravel-specific helpers (e.g., response()->export()). Create a facade or use a wrapper like:

     // app/Exports/ExportFacade.php
     class ExportFacade extends \Illuminate\Support\Facades\Facade {
         protected static function getFacadeAccessor() {
             return new ExportService();
         }
     }
     

Debugging Tips

• Validate Data Structure:

  $serializer = new Serializer();
  try {
      $serializer->serialize($data, 'csv');
  } catch (\Exception $e) {
      dd($e->getMessage(), $data); // Check for invalid keys/values
  }
  

• Log Headers:

  \Log::debug('Response Headers:', [
      'Content-Type' => $response->headers->get('Content-Type'),
      'Disposition' => $response->headers->get('Content-Disposition'),
  ]);
  

Extension Points

1. Custom Encoders:

   • Implement Symfony\Component\Serializer\Encoder\EncoderInterface for formats like JSONL or XML:

     class JsonlEncoder implements EncoderInterface {
         public function encode($data, $format, array $context = []) {
             return implode("\n", array_map('json_encode', $data));
         }
         // ... other methods
     }
     

   • Register with the serializer:

     $serializer = new Serializer([], [new JsonlEncoder()]);
     

2. Pre/Post-Processing:

   • Use Symfony’s Normalizer callbacks or Context to modify data before export:

     $context = [
         'csv_headers' => ['custom_id', 'formatted_name'],
         'csv_separator' => ';',
     ];
     

3. Laravel Service Provider:

   • Bind the serializer to the container for dependency injection:

     // app/Providers/AppServiceProvider.php
     public function register() {
         $this->app->singleton(Serializer::class, fn() => new Serializer(
             [new ObjectNormalizer()],
             [new CsvEncoder()]
         ));
     }
     

Performance Quirks

• Avoid Serializing Entire Collections:
  • Use cursor() or chunk() for Eloquent queries to reduce memory usage.
• Disable Debug Mode:
  • Symfony’s serializer logs warnings in debug mode. Set APP_DEBUG=false in production.

Community Workarounds

• For Laravel-Specific Features:
  • Fork the package or use alternatives like:
    • maatwebsite/excel (for advanced Excel/CSV).
    • spatie/laravel-data-export (Laravel-native).