Hof Plexexport Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Symfony/Laravel Compatibility: The bundle is designed for Symfony 2.1+ (using the Symfony2 bundle pattern), not Laravel. While Laravel shares some PHP/Symfony components (e.g., Twig, routing), direct integration would require significant abstraction or a wrapper layer.
• Monolithic vs. Modular: The bundle assumes a Symfony monolithic kernel (AppKernel.php), which Laravel’s service container and routing system does not natively support. A Laravel-specific adapter would need to:
  • Replace Symfony’s ContainerAware services with Laravel’s ServiceProvider/Binding system.
  • Reimplement bundle registration via Laravel’s config/app.php or a custom ServiceProvider.
• Twig Dependency: The bundle relies on Twig templates (plex_movies.html.twig), which Laravel supports but requires explicit configuration (e.g., via Blade or a Twig bridge like laravel-twig).

Integration Feasibility

• Low: The bundle’s hardcoded Symfony assumptions (e.g., Kernel, Bundle inheritance) make direct adoption in Laravel non-trivial. Key hurdles:
  • Routing: Symfony’s routing.yml vs. Laravel’s routes/web.php.
  • Configuration: YAML-based config (config.yml) vs. Laravel’s PHP/ENV-based config.
  • Service Container: Symfony’s ContainerInterface vs. Laravel’s Container/ServiceProvider.
• Workarounds:
  • Option 1: Fork the bundle and rewrite it as a Laravel package (e.g., using Illuminate\Support\ServiceProvider).
  • Option 2: Use the underlying library (Plex-Export) directly in Laravel, bypassing the Symfony bundle layer.
  • Option 3: Create a thin Laravel wrapper that maps Symfony bundle features to Laravel equivalents (e.g., Twig templates → Blade, AppKernel → AppServiceProvider).

Technical Risk

Key Questions

1. Is the underlying Plex-Export library sufficient, or does the Symfony bundle add critical value (e.g., caching, UI integration)?
2. What’s the priority: Quick integration (use Plex-Export directly) vs. long-term maintainability (rewrite as Laravel package)?
3. How will templates be handled? Twig (via bridge) or Blade (converted from Twig)?
4. What’s the data flow? Will exports be served via Symfony’s Controller or Laravel’s Route?
5. Are there existing Laravel Plex integrations (e.g., spatie/laravel-plex) that could replace this?

Integration Approach

Stack Fit

• Laravel Compatibility: Low (Symfony-centric design). The bundle’s core functionality (Plex media export) is viable, but the delivery mechanism (Symfony bundle) is not.
• Recommended Stack:
  • Backend: Laravel 9+/10+ (PHP 8.0+).
  • Templates: Blade (preferred) or Twig (via laravel-twig).
  • Configuration: Laravel’s config/plex.php (replace YAML).
  • Routing: Laravel’s Route::get('/plex-export', ...).
  • Services: Laravel’s ServiceProvider or PackageServiceProvider.

Migration Path

1. Option A: Direct Library Integration (Low Effort)

   • Replace the Symfony bundle with the Plex-Export library.
   • Steps:
     • Composer: composer require dachande663/plex-export.
     • Create a Laravel ServiceProvider to wrap the library.
     • Example:

       // app/Providers/PlexExportServiceProvider.php
       use Dachande663\PlexExport\PlexExport;
       class PlexExportServiceProvider extends ServiceProvider {
           public function register() {
               $this->app->singleton(PlexExport::class, function ($app) {
                   return new PlexExport([
                       'plex_url' => config('plex.url'),
                       'data_dir' => storage_path('plex-exports'),
                   ]);
               });
           }
       }
       

     • Use Blade/Twig to render exports.

2. Option B: Laravel Bundle Wrapper (Medium Effort)

   • Fork the Symfony bundle and rewrite it as a Laravel package.
   • Key changes:
     • Replace Bundle with ServiceProvider.
     • Convert YAML config to Laravel’s config/plex.php.
     • Replace Twig templates with Blade or Twig (via bridge).
     • Example structure:

       /packages/laravel-plexexport/
       ├── src/
       │   ├── ServiceProvider.php
       │   ├── PlexExportFacade.php
       │   ├── Views/ (Blade/Twig templates)
       ├── config/plex.php
       ├── routes/web.php
       

3. Option C: Hybrid Approach (High Effort)

   • Keep the Symfony bundle for legacy systems and expose its API via Laravel.
   • Use Laravel’s HTTP client to call a Symfony microservice running the bundle.

Compatibility

Sequencing

1. Phase 1: Proof of Concept (1-2 days)

   • Test Plex-Export library directly in Laravel.
   • Verify core functionality (exporting media, thumbnails, sections).

2. Phase 2: Configuration Abstraction (1 day)

   • Migrate YAML config to Laravel’s config/plex.php.
   • Example:

     // config/plex.php
     return [
         'plex_url' => env('PLEX_URL', 'http://localhost:32400'),
         'data_dir' => storage_path('plex-exports'),
         'thumbnail_width' => 150,
         'sections' => ['movies', 'shows'],
     ];
     

3. Phase 3: Template Integration (1 day)

   • Convert Twig templates to Blade or set up laravel-twig.
   • Example Blade template (resources/views/plex/export.blade.php):

     @foreach($plexExport->getMovies() as $movie)
         <div>
             <img src="{{ $movie->getThumbnailUrl() }}" width="150">
             <h3>{{ $movie->getTitle() }}</h3>
         </div>
     @endforeach
     

4. Phase 4: Routing & API (1 day)

   • Add Laravel routes:

     Route::get('/plex-export', [PlexExportController::class, 'index']);
     

   • Create a controller to handle exports:

     class PlexExportController extends Controller {
         public function index(PlexExport $plexExport) {
             return view('plex/export', [
                 'plexExport' => $plexExport->export(),
             ]);
         }
     }
     

5. Phase 5: Testing & Optimization (2-3 days)

   • Test with large Plex libraries.
   • Optimize thumbnail generation (caching, async processing).
   • Add Laravel-specific features (e.g., caching exports with cache()->remember).

Operational Impact

Maintenance

• Symfony Bundle: High maintenance overhead due to Laravel-Symfony divergence.
• Laravel Adaptation:
  • Low: If using Plex-Export directly or a well-abstracted package.
  • Medium: If forking the Symfony bundle (requires dual maintenance).
• Dependencies:
  • Plex-Export library (stable, MIT-licensed).
  • Twig bridge (if using Twig): tightenco/laravel-twig.

Support

• Community: Minimal (1 star, no dependents). Support would rely on:
  • Original Plex-Export repo (active).
  • Laravel community for adaptation questions.
• Debugging:
  • Symfony-specific errors (e.g., Bundle not found) would