Action Bundle Laravel Package

Product Decisions This Supports

• Architectural Modernization: Adopting this package enables a shift toward dependency injection (DI) best practices in Symfony controllers and commands, aligning with modern PHP/Symfony standards (e.g., PSR-11 containers, autowiring). This reduces technical debt from legacy service container access patterns ($this->get()) and improves testability.
• Developer Experience (DX) Improvements: Accelerates onboarding for new engineers by enforcing explicit dependencies in constructors, reducing "magic" service lookups. Supports a cleaner separation of concerns for API/CLI logic.
• Roadmap for Microservices/API-First: Ideal for teams building decoupled Symfony APIs (e.g., REST/GraphQL) where controllers are treated as stateless services. The bundle’s service registration simplifies integration with tools like API Platform or Mercure.
• Build vs. Buy: Buy if your team is already using Symfony and wants to avoid reinventing DI patterns for controllers/commands. Build only if you need custom controller resolution logic (e.g., dynamic routing) not covered by this bundle.
• Use Cases:
  • Migrating legacy Symfony apps to modern DI practices.
  • Standardizing CLI command development with autowired dependencies.
  • Enabling headless Symfony (e.g., API-only projects) where controllers are treated as services.

When to Consider This Package

• Adopt if:

  • Your team uses Symfony 2.8+ (autowiring support) and wants to enforce explicit DI in controllers/commands.
  • You’re building API-first or decoupled Symfony applications (e.g., microservices).
  • Legacy code relies on $this->get() or manual service registration, increasing maintenance costs.
  • You prioritize testability and static analysis (e.g., PHPStan, Psalm) over quick prototyping.

• Look elsewhere if:

  • You’re using Symfony 3.x or earlier (autowiring was introduced in 2.8).
  • Your project requires dynamic controller resolution (e.g., route-based class loading) beyond this bundle’s scope.
  • You’re already using alternatives like:
    • Symfony’s native autowiring (if you don’t need bundle-specific features).
    • API Platform (for API-focused projects with built-in DI).
    • Laminas MVC or Slim PHP (if migrating away from Symfony).
  • The package’s last release in 2017 is a blocker (though core concepts remain valid).

How to Pitch It (Stakeholders)

For Executives:

"This package modernizes our Symfony controllers and CLI commands by enforcing clean dependency injection—reducing technical debt, improving code quality, and accelerating development. It’s a low-risk upgrade (MIT license) that aligns with industry best practices, making our APIs and tools more maintainable and scalable. Think of it as ‘autopilot for Symfony services’—no more manual service lookups, just plug-and-play components."

For Engineering:

*"DunglasActionBundle replaces Symfony’s default controllers/commands with autowired services, eliminating $this->get() anti-patterns. Benefits:

• Faster onboarding: New devs won’t struggle with service container hacks.
• Better tests: Controllers/commands are easier to mock and unit test.
• Future-proof: Works seamlessly with Symfony’s autowiring and modern tooling. Tradeoff: Last updated in 2017, but the core philosophy (explicit DI) is evergreen. We can wrap it or extend it if needed."*

For Architects:

*"This bundle standardizes controller/service boundaries in Symfony, which is critical for:

• Microservices: Treat controllers as disposable services.
• Performance: Reduces overhead from dynamic service lookups.
• Tooling: Plays well with API Platform, Mercure, or GraphQL bundles. Risk: Minimal—it’s a drop-in replacement for controllers/commands. If we hit limits, we can fork or supplement it."*