Aviary Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Pros:
  • Image Editing & Uploads: Aligns well with Laravel/Symfony hybrid projects requiring client-side image editing (Aviary) + multi-file uploads (BlueImp jQuery Uploader).
  • Symfony Bundle Structure: Leverages Doctrine ORM, Forms, and Twig—compatible with Laravel via Symfony Bridge (e.g., symfony/http-foundation, symfony/orm).
  • MIT License: Permissive for commercial use; no legal blockers.
• Cons:
  • Archived Status: No active maintenance (last commit: 2015). Risk of deprecated dependencies (e.g., friendsofsymfony/jsrouting-bundle at 2.0.*@dev).
  • Tight Coupling: Hardcodes Gallery entity and GalleryType—may require refactoring for Laravel’s Eloquent/Blade ecosystem.
  • Aviary API Dependency: Requires a paid Aviary API key (now part of Adobe’s Adobe Creative SDK). Potential cost and API changes risk.

Integration Feasibility

• Laravel Compatibility:
  • Symfony Components: Can integrate via symfony/console, symfony/orm, and symfony/form (Laravel 9+ supports Symfony 5.4+ components).
  • Twig: Replaceable with Blade via custom templating logic.
  • JavaScript: BlueImp Uploader and Aviary Feather are standalone libraries—can be included via CDN or npm.
• Database Schema:
  • Doctrine Gallery entity must be mapped to Laravel Eloquent models (e.g., hasOne relationship).
  • Migration Risk: Schema changes may break if Laravel uses a different DB structure.

Technical Risk

Key Questions

1. Why Aviary?

   • Is the image editing functionality critical, or can it be replaced with a client-side library (e.g., Cropper.js + Fabric.js)?
   • Are there cost constraints with Adobe’s API?

2. Laravel-Symfony Hybrid Feasibility

   • Will the team maintain dual Symfony/Laravel codebases, or is a full rewrite (e.g., using Laravel’s dropzone.js + spatie/laravel-medialibrary) preferable?

3. Performance & Scaling

   • How will large file uploads (BlueImp Uploader) scale? Are chunked uploads or queue workers (e.g., Laravel Horizon) needed?

4. Security

   • How will file validation (e.g., MIME types, malicious uploads) be handled? The bundle lacks explicit security documentation.

5. Long-Term Maintenance

   • If archived, who will fix bugs or update dependencies? Is a custom fork justified?

Integration Approach

Stack Fit

• Frontend:
  • BlueImp jQuery File Uploader: Works with Laravel Mix/Webpack or Vite for asset bundling.
  • Aviary Feather: Requires CDN inclusion or npm (@adobe/aviary-sdk). Conflicts possible with Laravel’s existing JS libraries (e.g., jQuery version mismatches).
• Backend:
  • Symfony Components: Use symfony/http-foundation for request handling, symfony/orm for Doctrine compatibility (if needed).
  • Laravel Alternatives:
    • Uploads: spatie/laravel-medialibrary or intervention/image.
    • Image Editing: spatie/image-optimizer or client-side libraries.
• Database:
  • Doctrine → Eloquent: Map Gallery entity to a Laravel model with hasOne/belongsTo relationships.
  • Migrations: Use Laravel’s migration system to adapt the schema.

Migration Path

1. Assessment Phase:

   • Audit existing Laravel project for conflicting dependencies (e.g., jQuery, Doctrine).
   • Test BlueImp Uploader and Aviary Feather in isolation (no Symfony bundle).

2. Hybrid Integration:

   • Option A (Partial Integration):
     • Use only the frontend components (BlueImp + Aviary) via CDN/npm.
     • Replace Symfony backend logic with Laravel controllers (e.g., handle uploads via Request and Storage facade).
   • Option B (Full Bundle Integration):
     • Install Symfony components (composer require symfony/orm symfony/form).
     • Create a Laravel service provider to register the bundle (e.g., AviaryBundle as a Symfony bridge).
     • Override Symfony-specific logic (e.g., GalleryType) with Laravel forms.

3. Database Sync:

   • Generate a Laravel migration for the Gallery table:

     Schema::create('galleries', function (Blueprint $table) {
         $table->id();
         $table->string('path');
         $table->json('metadata')->nullable();
         $table->timestamps();
     });
     

   • Create an Eloquent model:

     class Gallery extends Model {
         public function product() { return $this->belongsTo(Product::class); }
     }
     

4. Frontend Setup:

   • Include BlueImp Uploader and Aviary Feather via CDN or npm.
   • Replace Twig templates with Blade views (e.g., resources/views/aviary/fields.blade.php).
   • Initialize Aviary Feather in a Laravel-specific JS file:

     document.addEventListener('DOMContentLoaded', () => {
         new Aviary.Feather({
             apiKey: '{{ config("services.aviary.api_key") }}',
             // ... config
         });
     });
     

5. Configuration:

   • Replace config.yml with Laravel’s config/aviary.php:

     return [
         'upload_path' => storage_path('app/public/uploads'),
         'api_key' => env('AVIARY_API_KEY'),
     ];
     

   • Use Laravel’s service provider to bind Symfony components:

     public function register() {
         $this->app->singleton('aviary.gallery_type', function () {
             return new \Appventus\AviaryBundle\Form\GalleryType();
         });
     }
     

Compatibility

Sequencing

1. Phase 1 (Frontend-Only):

   • Implement BlueImp Uploader + Aviary Feather without Symfony backend.
   • Use Laravel’s Storage facade for file handling.

2. Phase 2 (Hybrid Backend):

   • Integrate Symfony Form components via service container.
   • Map Doctrine entities to Eloquent models.

3. Phase 3 (Full Replacement):

   • Replace AviaryBundle with Laravel-native solutions (e.g., spatie/laravel-medialibrary + client-side editing).

Operational Impact

Maintenance

• Pros:
  • MIT License: No vendor lock-in.
  • Standalone JS Libraries: BlueImp and Aviary can be updated independently.
• Cons:
  • **