Sonata Admin Laravel Package

Technical Evaluation

Architecture Fit

• Admin Panel Integration: SonataAdmin is a well-established PHP admin bundle for Symfony, providing CRUD interfaces, list views, and form management. This package extends its functionality to integrate with Splash Connectors, a custom object management system for connectors (likely APIs, webhooks, or data pipelines).
• Symfony Ecosystem Alignment: If the application is built on Symfony (or a Symfony-compatible stack), this package fits seamlessly. For non-Symfony Laravel projects, integration would require a Symfony bridge (e.g., via symfony/ux or api-platform), adding complexity.
• Domain-Specific Value: Ideal for projects managing external connectors (e.g., payment gateways, SaaS integrations, IoT devices) where admin users need to configure, monitor, or debug connections without direct API exposure.

Integration Feasibility

• Laravel Compatibility:
  • Low: SonataAdmin is Symfony-centric. Direct Laravel integration would require:
    • A Symfony microkernel or Laravel-Symfony bridge (e.g., symfony/panther for testing, but not admin panels).
    • Rewriting SonataAdmin’s Twig templates to Blade (manual effort).
    • Using a headless Symfony API (e.g., via api-platform) to serve admin data to a Laravel frontend.
  • Alternative: Evaluate Laravel-native alternatives like:
    • backpack/l5-repository (for CRUD + repositories).
    • spatie/laravel-admin (simpler, Laravel-first).
    • orchid/software (modern admin panel).
• Database/ORM:
  • SonataAdmin relies on Doctrine ORM (Symfony’s default). Laravel uses Eloquent. Migrating between them requires:
    • A shared database schema (e.g., using Doctrine in Laravel via doctrine/dbal).
    • Custom Eloquent-Doctrine adapters for complex queries.
  • Risk: Schema mismatches or performance degradation if not optimized.

Technical Risk

Key Questions

1. Why SonataAdmin?

   • Does the project require SonataAdmin’s advanced features (e.g., dynamic forms, ACLs, batch actions), or would a lighter Laravel admin suffice?
   • Are there existing Symfony components in the stack that justify this dependency?

2. Connector Complexity

   • How many/what types of connectors need management? SonataAdmin’s flexibility may be overkill for simple CRUD.
   • Are connectors stateful (e.g., require polling, retries)? SonataAdmin lacks built-in async support.

3. Long-Term Maintenance

   • Is the team comfortable with Symfony’s ecosystem (e.g., Twig, Doctrine, Symfony Console)?
   • What’s the deprecation risk? SonataAdmin is mature but may lag behind Laravel’s pace.

4. Performance

   • SonataAdmin’s admin panels can be resource-heavy. How will this impact Laravel’s frontend (e.g., if using SPA frameworks like Inertia.js)?

5. Alternatives

   • Has spatie/laravel-admin or backpack been evaluated for connector management?
   • Could connectors be managed via Laravel Nova (if using Tailwind/Blade) or FilamentPHP?

Integration Approach

Stack Fit

• Best Fit: Symfony + Laravel Hybrid Architecture

  • Symfony Kernel: Host SonataAdmin and Splash Connectors as a microservice or sub-application.
  • Laravel Frontend: Consume Symfony’s admin API via:
    • GraphQL (e.g., webonyx/graphql-php).
    • REST (Symfony’s api-platform).
    • WebSockets (for real-time connector events).
  • Shared Database: Use Doctrine DBAL in Laravel to interact with the same tables as SonataAdmin.

• Pure Laravel Workaround:

  • Option 1: Rewrite SonataAdmin’s core logic in Laravel:
    • Port SonataAdminBundle’s Admin classes to Laravel services.
    • Replace Twig with Blade.
    • Use Eloquent instead of Doctrine (manual mapping).
  • Option 2: Use Symfony Components in Laravel:
    • Add symfony/console, symfony/dependency-injection, and doctrine/orm via Composer.
    • Build a lightweight admin layer on top of these components.

Migration Path

1. Assessment Phase (2 weeks)

   • Audit existing connector management logic.
   • Define minimum viable scope (e.g., "only list/edit connectors, no ACLs").
   • Benchmark performance of SonataAdmin vs. Laravel alternatives.

2. Proof of Concept (3 weeks)

   • Set up a Symfony subdirectory in the Laravel project (e.g., /symfony-admin).
   • Integrate Splash Connectors with SonataAdmin.
   • Test CRUD operations via Symfony’s admin panel.
   • Expose a REST API endpoint for Laravel to consume.

3. Hybrid Integration (4-6 weeks)

   • Option A (Recommended): Deploy Symfony admin as a separate service (Docker container) and integrate via API.
     • Use Laravel Horizon for async connector tasks.
     • Sync data between Laravel and Symfony via database events or message queues (Laravel + Symfony Messenger).
   • Option B: Gradually replace Symfony components with Laravel equivalents (higher risk).

4. Laravel Frontend Adaptation (2 weeks)

   • Build a Laravel admin dashboard (using Inertia.js/Vue or FilamentPHP) that fetches data from Symfony’s API.
   • Implement authentication sync (e.g., Laravel Sanctum + Symfony Guard).

Compatibility

Sequencing

1. Phase 1: Isolate Symfony

   • Containerize Symfony admin in Docker.
   • Expose a read-only API for Laravel to consume.

2. Phase 2: Core Functionality

   • Implement connector CRUD in SonataAdmin.
   • Add basic validation and event logging.

3. Phase 3: Laravel Integration

   • Build a Laravel service layer to interact with Symfony’s API.
   • Replace Symfony-specific features (e.g., ACLs) with Laravel policies.

4. Phase 4: Optimization

   • Cache API responses (e.g., using Laravel’s cache or Symfony’s VarCache).
   • Add real-time updates via Laravel Echo + Symfony Mercure.

Operational Impact

Maintenance

• Pros:
  • SonataAdmin is battle-tested for admin panels (used in ~500K projects).
  • Splash Connectors are centralized, reducing duplicate logic.
  • Symfony’s dependency injection and console commands simplify maintenance.
• Cons:
  • Dual-stack complexity: Maintaining Symfony + Laravel increases cognitive load.
  • Template updates: Twig templates may need manual syncing if using Blade.
  • Dependency bloat: Symfony components add ~50MB to Composer dependencies.

Support

• Symfony Ecosystem: