Currency Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Symfony-Centric Design: The bundle is tightly coupled with Sylius, a Symfony-based eCommerce platform, and assumes a Symfony ecosystem (DependencyInjection, Doctrine ORM, etc.). If the target system is Laravel, this introduces a fundamental mismatch in architecture, as Laravel uses Laravel Service Container, Eloquent ORM, and lacks Symfony’s DI container.
• Component Isolation: The underlying SyliusCurrency component (if standalone) could be ported, but the bundle itself is Symfony-specific (e.g., uses sylius/resource-bundle for CRUD, sylius/doctrine-currency for storage).
• Laravel Alternatives: Laravel has native support for currencies via Eloquent models, monetary libraries (e.g., moneyphp/money) or packages like spatie/currency. Reimplementing this logic in Laravel would likely be more efficient than integrating a Symfony bundle.

Integration Feasibility

• Low Feasibility: Direct integration into Laravel is not viable without heavy refactoring:
  • Symfony’s ContainerInterface → Laravel’s Container (incompatible).
  • Doctrine ORM → Eloquent (different query builders, repositories).
  • Sylius-specific services (e.g., sylius/resource/registry) → No direct Laravel equivalent.
• Workarounds:
  • API Wrapper: Expose Sylius as a microservice and consume its currency API (if available).
  • Component Extraction: Manually port the SyliusCurrency component (PHP 8.1+, no Symfony dependencies) into Laravel, but this requires significant effort (e.g., rewriting Doctrine entities for Eloquent).
  • Feature Parity: Rebuild functionality using Laravel packages (e.g., spatie/currency + custom logic for multi-currency support).

Technical Risk

Key Questions

1. Why Symfony/Sylius?

   • Is the team already invested in Sylius, or is this a legacy dependency?
   • Are there non-functional requirements (e.g., Sylius’s multi-currency tax logic) that Laravel packages lack?

2. Scope of Integration

   • Does the system need only currency storage (use spatie/currency) or full Sylius currency workflows (e.g., exchange rates, tax calculations)?

3. Long-Term Viability

   • Is the bundle actively maintained? (Archived status is a red flag.)
   • Are there Laravel-compatible forks or alternatives?

4. Migration Path

   • Can currency data be exported from Sylius and imported into Laravel (e.g., via seeders)?
   • Are there breaking changes in Sylius’s currency component that would affect a port?

5. Team Expertise

   • Does the team have Symfony/Laravel cross-framework experience?
   • Is there budget for custom development to bridge the gap?

Integration Approach

Stack Fit

• Incompatible Stack:
  • Symfony Bundle → Laravel’s Service Container, Eloquent, and Blade/Templating are non-overlapping.
  • Doctrine ORM → Laravel’s Eloquent (different query syntax, events, repositories).
  • Sylius-Specific Services (e.g., sylius/resource-bundle) → No Laravel equivalents.
• Partial Fit:
  • The underlying SyliusCurrency component (if extracted) could theoretically work in Laravel if:
    • All Symfony dependencies are removed.
    • Doctrine entities are converted to Eloquent models.
    • Service wiring is rewritten for Laravel’s container.

Migration Path

Recommended Path:

1. Assess Feature Parity:
   • List all required currency features (e.g., dynamic rates, tax integration, admin UI).
   • Compare with Laravel packages (spatie/currency, moneyphp/money).
2. If Sylius-Specific Logic is Needed:
   • Extract the minimal viable component from Sylius (e.g., Sylius\Component\Currency).
   • Port to Laravel:
     • Convert Doctrine entities → Eloquent models.
     • Rewrite services to use Laravel’s bind()/singleton().
     • Replace Symfony events → Laravel’s events facade.
3. Fallback to API:
   • Deploy Sylius as a separate service and call its currency API from Laravel.

Compatibility

• PHP Version: Check if the bundle supports Laravel’s PHP version (e.g., 8.0+).
• Doctrine vs. Eloquent:
  • Example incompatibility: Sylius uses sylius/resource-bundle for CRUD; Laravel uses resource controllers or API resources.
• Configuration:
  • Symfony’s config/packages/sylius_currency.yaml → Laravel’s config/currency.php.
• Database:
  • Sylius uses Doctrine migrations; Laravel uses Eloquent migrations.

Sequencing

1. Phase 1: Feasibility Study (1-2 weeks)
   • Audit the bundle’s dependencies.
   • Identify critical vs. optional features.
   • Prototype a minimal port (e.g., currency model + exchange rate service).
2. Phase 2: Decision Point
   • If porting is viable, proceed with extraction.
   • If not, select a Laravel-native alternative and build custom logic.
3. Phase 3: Integration
   • For porting: Rewrite services, test with Laravel’s container.
   • For API: Set up Sylius as a microservice, integrate via HTTP/GraphQL.
4. Phase 4: Data Migration
   • Export Sylius currency data (e.g., via Sylius admin API).
   • Import into Laravel using seeders/factories.

Operational Impact

Maintenance

• High Ongoing Cost:
  • Symfony-Specific Code: Requires dual expertise (Symfony/Laravel).
  • Archived Bundle: No updates; security/bug fixes must be backported.
  • Dependency Drift: Sylius and Laravel evolve independently (e.g., Symfony 6.x vs. Laravel 10.x).
• Laravel-Native Solution:
  • Lower maintenance (uses standard Laravel patterns).
  • Easier to debug (familiar stack traces, tools like Tinker).

Support

• Limited Community Support:
  • Bundle is archived with 0 stars/dependents.
  • Sylius community is Symfony-focused; Laravel-specific issues may go unanswered.
• Workarounds:
  • Open issues in the Sylius Slack/GitHub (but expect Symfony-centric responses).
  • Hire a Symfony/Laravel polyglot for troubleshooting.

Scaling

• Performance:
  • Direct Integration: Minimal overhead if using API (adds network latency).
  • Ported Component: Similar performance to native Laravel (depends on implementation).
• Horizontal Scaling:
  • API-based approach scales well (Sylius and Laravel can scale independently).
  • Monolithic porting may require shared database or event-driven sync.

Failure Modes

Ramp-Up

• Team Learning Curve:
  • Symfony Concepts: If the team is Laravel