Hosting Laravel Package

Technical Evaluation

Architecture Fit

• Symfony-Centric Design: The bundle is tightly coupled with Symfony (v7+) and leverages its ecosystem (e.g., dependency injection, console commands, health checks). This aligns well with Laravel-based projects only if using Symfony components (e.g., Symfony HTTP Kernel, Symfony Console) or via Lumen/Symfony bridges (e.g., spatie/laravel-symfony).
• Modular Hooks System: The BuildHookInterface/DeployHookInterface pattern is highly extensible and could be adapted for Laravel’s service providers or event listeners (e.g., booted, registered).
• Health Checks: The live/ready health check infrastructure maps to Laravel’s PingEndpoints or UptimeRobot integrations but requires custom implementation.
• Build Info System: Event-based build metadata collection (e.g., Git tags, timestamps) could replace Laravel’s config('app.version') or artisan package:discover with more granularity.

Integration Feasibility

• Laravel Compatibility:
  • Low: No native Laravel support (Symfony-only). Requires wrapper classes or Symfony container integration (e.g., spatie/laravel-symfony).
  • Workarounds:
    • Use Symfony’s ConsoleComponent for CLI hooks (e.g., post-deploy).
    • Adapt HostingEnvironment to Laravel’s config() or env().
    • Replace Doctrine health checks with Laravel’s database migrations or queue workers.
• Key Dependencies:
  • Symfony 7+: Laravel’s Symfony bridge (e.g., spatie/laravel-symfony) may mitigate this but adds complexity.
  • PHP 8.4+: Laravel 10+ supports this, but backward compatibility with older Laravel versions (e.g., 9.x) would require polyfills.

Technical Risk

• Breaking Changes: Version 4.0.0+ introduces config key changes (hosting → 21torr_hosting) and deprecated interfaces, requiring migration effort.
• Symfony Lock-in: Heavy reliance on Symfony’s EventDispatcher, Console, and DependencyInjection may complicate Laravel integration.
• Undocumented Features: Limited adoption (0 stars, 0 dependents) suggests unproven stability or hidden edge cases.
• Lack of Laravel-Specific Guides: No examples for Laravel service providers, Artisan commands, or queue workers.

Key Questions

1. Why Symfony? If the goal is Laravel-native, evaluate alternatives like:
   • spatie/laravel-deployer (for CI/CD hooks).
   • laravel-zero/framework (for CLI tools).
   • Custom Laravel Events + Service Providers.
2. What’s the ROI? For a Laravel project, the bundle’s Symfony-specific features (e.g., Doctrine health checks) may not justify integration unless:
   • You’re migrating to Symfony.
   • You need Symfony’s health check infrastructure (e.g., Kubernetes probes).
3. Maintenance Burden:
   • Will the team maintain Symfony compatibility long-term?
   • How will Laravel updates (e.g., PHP 8.4+) interact with this bundle?
4. Alternatives:
   • For CI/CD hooks: deployer/deployer or laravel/envoy.
   • For health checks: spatie/laravel-health or beberlei/assert.
   • For build metadata: Laravel’s config('app') or composer.json parsing.

Integration Approach

Stack Fit

• Laravel + Symfony Hybrid:
  • Use spatie/laravel-symfony to bridge Symfony’s ConsoleComponent and DependencyInjection.
  • Replace Symfony’s EventDispatcher with Laravel’s Events (e.g., Illuminate\Foundation\Bootstrap\BootServiceProvider).
• Pure Laravel Workarounds:
  • Build Hooks: Replace hosting:hook:build with Laravel’s booted event or Artisan commands.
  • Deploy Hooks: Use post-deploy scripts in .env or GitHub Actions.
  • Health Checks: Implement Laravel’s Http\Middleware\CheckForMaintenanceMode or spatie/laravel-health.
  • Build Info: Store metadata in config('app.build_info') or database cache.

Migration Path

1. Phase 1: Proof of Concept (2 weeks)
   • Integrate only the HostingEnvironment class to test Symfony ↔ Laravel compatibility.
   • Replace Symfony’s ContainerInterface with Laravel’s Container via spatie/laravel-symfony.
2. Phase 2: Core Features (4 weeks)
   • Adapt BuildHookInterface to Laravel’s Service Providers (e.g., register() for post-build).
   • Replace Doctrine health checks with Laravel’s migration checks or queue:failed.
   • Implement hosting:validate-app as a custom Artisan command.
3. Phase 3: Full Adoption (Ongoing)
   • Migrate config keys (21torr_hosting → hosting in Laravel’s config/services.php).
   • Replace Symfony console commands with Laravel Artisan commands.
   • Deprecate Symfony-specific features in favor of Laravel-native solutions.

Compatibility

Sequencing

1. Start with Non-Symfony Features:
   • Use HostingEnvironment for environment detection (e.g., isDebug()).
   • Adopt build info for version tracking.
2. Avoid Early Symfony Dependencies:
   • Delay integrating Doctrine health checks until Laravel’s database layer is fully migrated.
3. Last: CLI Hooks:
   • Implement hosting:hook:build as a custom Artisan command only if critical.

Operational Impact

Maintenance

• Symfony Dependency Overhead:
  • Requires dual maintenance of Symfony and Laravel stacks (e.g., updating spatie/laravel-symfony).
  • PHP 8.4+ may force Laravel upgrades, increasing testing effort.
• Config Management:
  • 21torr_hosting config key conflicts with Laravel’s services.php structure.
  • Solution: Use Laravel’s config/services.php with a custom wrapper class.
• Logging:
  • Symfony’s Monolog may not integrate seamlessly with Laravel’s Log::channel().
  • Mitigation: Standardize on Monolog via spatie/laravel-log.

Support

• Limited Community:
  • 0 stars/dependents → no public support channels (e.g., GitHub issues, Stack Overflow).
  • Workaround: Engage with 21TORR’s internal team (if applicable) or fork the repo.
• Debugging Complexity:
  • Symfony ↔ Laravel integration bugs may require deep knowledge of both frameworks.
  • Recommendation: Allocate 10% of sprint time for troubleshooting.

Scaling

• Performance Impact:
  • Health checks add HTTP overhead (e.g., /up endpoint).
  • Build hooks may slow down deployments if not optimized.
  • Mitigation: Cache health check results (e.g., Laravel’s Cache::remember()).
• Multi-Environment Scaling:
  • HostingTier could help isolate tenant environments, but requires custom Laravel implementation.
  • Alternative: Use Laravel Horizon for queue-based scaling.

Failure Modes