Page Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Symfony-Centric Design: The bundle is tightly coupled with Symfony (6.4+/7.x) and the Aropixel AdminBundle, making it a strong fit for Symfony-based projects but non-portable to Laravel or other PHP frameworks. For Laravel, this requires a wrapper layer or Symfony bridge (e.g., Symfony’s HTTP Kernel in Laravel via spatie/symfony-laravel-bridge).
• Page-Centric Architecture: The bundle’s three-tiered page model (CKEditor, visual builder, structured JSON) aligns well with content-heavy Laravel apps (e.g., marketing sites, CMS-driven apps). The pre-rendered HTML approach reduces frontend complexity, which is valuable for Laravel’s blade-based templating.
• Event-Driven Extensibility: The PageSavedEvent hook enables cache invalidation (Varnish, Redis) and post-save logic, which can be adapted to Laravel’s event system or service containers.
• Doctrine ORM Dependency: Heavy reliance on Doctrine (migrations, entities) requires Laravel’s Eloquent-to-Doctrine bridge (e.g., doctrine/orm + laravel-doctrine/orm) or a custom data layer.

Integration Feasibility

• High Effort for Laravel: Direct integration is not trivial due to:
  • Symfony’s dependency injection (DI) vs. Laravel’s service container.
  • Doctrine ORM vs. Eloquent (migrations, repositories).
  • Twig templates vs. Blade (requires twig/bridge or custom adapters).
• Workarounds:
  • Symfony Microkernel in Laravel: Embed Symfony’s HTTP Kernel (e.g., for admin routes) while keeping Laravel for frontend.
  • Hybrid Data Layer: Use Doctrine for the bundle’s entities but expose them via Eloquent models (e.g., via API resources or custom repositories).
  • Static Page Builder: Extract the visual builder’s frontend logic (JavaScript/YAML) and adapt it to Laravel’s asset pipeline (Vite/Webpack).
• Frontend Compatibility: The pre-rendered HTML approach works well with Laravel’s blade templates, but the admin UI (Aropixel AdminBundle) must be either:
  • Replaced with a Laravel-compatible admin panel (e.g., Filament, Nova).
  • Isolated in an iframe or micro-frontend.

Technical Risk

Key Questions

1. Is the visual page builder’s core logic (JSON → HTML) reusable without the Symfony stack?
   • If yes: Extract the JavaScript/YAML logic and adapt it to Laravel’s frontend.
   • If no: Consider alternatives like Laravel Nova’s page builder or Spatie’s CMS.
2. Can the admin UI be replaced or isolated?
   • If the goal is a Laravel-native admin, the Aropixel AdminBundle may need replacement (e.g., with Filament or Backpack).
3. What’s the fallback for multilingual support?
   • Laravel has native i18n (e.g., spatie/laravel-translatable), but the bundle’s Gedmo Translatable integration would need adaptation.
4. How will cache invalidation (PageSavedEvent) work in Laravel?
   • Laravel’s event system can replace Symfony’s events, but Varnish/CDN hooks may require custom logic.
5. Is the bundle’s maturity acceptable?
   • With no updates since 2022 and low stars, consider forking or evaluating alternatives (e.g., CMS tools like October CMS).

Integration Approach

Stack Fit

• Laravel Compatibility: The bundle is not natively Laravel-compatible, but integration is possible via:
  • Symfony Microkernel: Embed Symfony for the bundle’s logic while using Laravel for the rest (e.g., frontend routes, Blade).
  • Hybrid Data Layer: Use Doctrine for the bundle’s entities but expose them via Eloquent models (e.g., via API resources or custom repositories).
  • Frontend Extraction: Decouple the visual page builder’s JavaScript and adapt it to Laravel’s asset pipeline (Vite/Webpack).
• Recommended Stack:
  • Backend: Laravel + Doctrine ORM (via doctrine/orm + laravel-doctrine/orm).
  • Frontend: Blade templates (for pre-rendered HTML) + Laravel Mix/Vite.
  • Admin UI: Replace Aropixel AdminBundle with Filament, Nova, or a custom Laravel admin.
  • Caching: Use Laravel’s cache drivers (Redis) and adapt PageSavedEvent to Laravel’s events.

Migration Path

1. Phase 1: Dependency Isolation

   • Install Symfony components required by the bundle (e.g., symfony/dependency-injection, doctrine/orm).
   • Use spatie/symfony-laravel-bridge to integrate Symfony’s DI container.
   • Set up Doctrine ORM alongside Eloquent (e.g., via laravel-doctrine/orm).

2. Phase 2: Data Layer Integration

   • Create Eloquent models that extend or wrap the bundle’s Doctrine entities.
   • Example:

     // App/Models/Page.php
     namespace App\Models;
     use Aropixel\PageBundle\Entity\Page as BasePage;
     use Doctrine\ORM\Mapping as ORM;
     use Illuminate\Database\Eloquent\Model;
     
     class Page extends Model
     {
         protected $entity = BasePage::class;
         // Delegate to Doctrine via a custom repository or trait.
     }
     

   • Adapt migrations to work with Laravel’s schema builder or use raw SQL.

3. Phase 3: Frontend Adaptation

   • Extract the page builder’s JavaScript from assets/ and rebuild it for Laravel’s Vite/Webpack.
   • Replace Twig templates with Blade (e.g., using twig/bridge or manual conversion).
   • Adapt the admin UI to use Laravel’s frontend (e.g., Inertia.js + Vue/React).

4. Phase 4: Event System Bridge

   • Replace PageSavedEvent with Laravel’s events:

     // Listen to page saves and invalidate cache.
     event(new PageSaved($page));
     

   • Use Laravel’s cache tags or Redis pub/sub for cache invalidation.

5. Phase 5: Admin UI Replacement

   • Replace Aropixel AdminBundle with a Laravel-compatible admin (e.g., Filament).
   • Rebuild the page management CRUD in Laravel’s admin panel.

Compatibility

Sequencing

1. Assess Feasibility: Evaluate if the bundle’s core features (visual builder, multilingual) are critical. If not, consider alternatives.
2. Prototype the Data Layer: Test Doctrine + Eloquent integration with a subset of entities.
3. Isolate the Frontend: Extract and rebuild the page builder’s JavaScript for Laravel.
4. Replace the Admin UI: Build a Laravel-native admin before fully committing.
5. Test Cache Invalidation: Ensure PageSavedEvent equivalents work with Laravel’s caching.
6. Performance Benchmark: