Doctrine Mongodb Admin Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Symfony/Sonata Ecosystem Alignment: The bundle is a direct extension of SonataAdminBundle, designed to integrate Doctrine MongoDB ODM into the existing Sonata admin framework. This makes it a natural fit for projects already using SonataAdminBundle (common in Symfony-based admin panels).
• Laravel Compatibility: While the bundle is Symfony-centric, its core functionality (MongoDB ODM integration with CRUD admin interfaces) can be leveraged in Laravel via:
  • Symfony Bridge Packages (e.g., symfony/console, symfony/dependency-injection).
  • Custom Laravel Service Providers to wrap Sonata’s components.
  • API Extraction: Reusing Sonata’s field description logic, datagrid, and form handling via standalone classes.
• Key Use Cases:
  • Admin Panels for MongoDB Collections: Ideal for Laravel projects using MongoDB (via jenssegers/mongodb or spatie/laravel-mongodb) that need a Sonata-like admin UI.
  • Hybrid ORM Projects: If a project uses both Eloquent and MongoDB, this bundle could provide a consistent admin layer for MongoDB models.

Integration Feasibility

• High-Level Integration Path:
  1. Symfony Dependency Injection: Use symfony/dependency-injection to manage Sonata services in Laravel.
  2. Service Provider Wrapping: Create a Laravel service provider to bootstrap Sonata’s MongoDB admin components.
  3. Route Integration: Use Laravel’s route model binding to map Sonata admin routes to Laravel controllers.
  4. Twig/Blade Hybrid: Replace Sonata’s Twig templates with Blade views while reusing its logic.
• Challenges:
  • Symfony-Specific Components: Some Sonata features (e.g., SonataAdminBundle’s event system) rely on Symfony’s EventDispatcher, which would need Laravel Event listeners as a bridge.
  • Doctrine ODM vs. Laravel MongoDB: The bundle assumes Doctrine MongoDB ODM, while Laravel typically uses jenssegers/mongodb (Eloquent). A custom ModelManager would be needed to adapt ODM queries to Laravel’s MongoDB queries.
  • Authentication/Authorization: Sonata integrates with Symfony’s security system; Laravel’s Gate/Policy system would need alignment.

Technical Risk

Key Questions for TPM

1. Why MongoDB in Laravel?
   • Is this for scalability, flexible schemas, or specific query needs? If Eloquent suffices, consider sticking with it.
2. Sonata vs. Custom Admin
   • Does the team need Sonata’s out-of-the-box features (datagrid, filters, batch actions), or would a custom Laravel admin panel (e.g., using Filament, Nova, or Backpack) be simpler?
3. Long-Term Viability
   • Given Sonata’s declining maintenance, is the team prepared to fork and maintain this bundle?
4. Alternative Packages
   • Are there Laravel-native MongoDB admin packages (e.g., spatie/laravel-admin with MongoDB support) that could reduce integration effort?
5. Team Expertise
   • Does the team have Symfony/Sonata experience? If not, the integration risk increases.
6. Performance Requirements
   • Sonata’s admin layer can be resource-intensive. Are there performance benchmarks for MongoDB usage?
7. Migration Path
   • If starting fresh, would it be better to build a lightweight Laravel admin panel instead of integrating Sonata?

Integration Approach

Stack Fit

Migration Path

1. Phase 1: Proof of Concept (PoC)

   • Set up a minimal Symfony environment to test Sonata’s MongoDB admin functionality.
   • Verify that core features (CRUD, filtering, sorting) work with Laravel’s MongoDB.
   • Benchmark performance against a custom Laravel admin solution.

2. Phase 2: Service Provider Integration

   • Create a Laravel Service Provider to:
     • Register Symfony’s DependencyInjection container.
     • Bootstrap Sonata’s ModelManager, Datagrid, and Admin services.
     • Override routing to work with Laravel’s router.
   • Example:

     // app/Providers/SonataMongoDBAdminServiceProvider.php
     public function register()
     {
         $this->app->register(SymfonyDependencyInjection::class);
         $this->app->singleton(ModelManager::class, function ($app) {
             return new CustomModelManager($app['mongodb']); // Laravel MongoDB
         });
     }
     

3. Phase 3: Template and View Layer

   • Replace Sonata’s Twig templates with Blade views by:
     • Extracting logic from Sonata’s templates into helper classes.
     • Using Blade-Twig for hybrid rendering.
   • Example:

     @extends('admin::base')
     @section('content')
         {{-- Use Sonata's logic via helper methods --}}
         @php
             $fieldDescription = app(SonataFieldDescriptionFactory::class)->create(...);
         @endphp
         {!! $fieldDescription->getType()->render($model) !!}
     @endsection
     

4. Phase 4: Routing and Controllers

   • Map Sonata admin routes to Laravel controllers:

     Route::get('/admin/posts', [SonataAdminController::class, 'list'])->name('admin.posts.list');
     

   • Use Laravel’s route model binding to pass MongoDB models to controllers.

5. Phase 5: Authentication and Authorization

   • Align Sonata’s security checks with Laravel’s Gates/Policies:

     // app/Policies/SonataAdminPolicy.php
     public function viewAny(User $user)
     {
         return $user->can('access_admin');
     }
     

Compatibility Considerations