Command Bus Bundle Laravel Package

Product Decisions This Supports

• Build vs. buy on command-bus infrastructure: This package is a candidate only as a reference implementation, not as a dependency. It bundles the CommandBus pattern (command → handler mapping) for Symfony, so it informs the decision "do we adopt a third-party bus, or implement ~200 lines of handler resolution ourselves?"
• CQRS-lite scoping: If a roadmap item is "separate write operations from controllers," this package demonstrates the minimal surface area that actually needs: a command interface, a handler interface, a registry, and a dispatcher. Use it to size that work, not to ship it.
• Framework fit check: The name says bundle, not package — this is a Symfony bundle, not a Laravel package. For a Laravel roadmap, it is a signal that the team must decide on Laravel's native bus (Illuminate\Bus, dispatch()) or Symfony Messenger, not this.
• Dependency-risk policy: 3 stars, 0 dependents, a last release in September 2021, and a low quality score make this a useful case study for setting a minimum bar (maintenance recency, adoption, transitive risk) that any infrastructure dependency must clear.
• Make-vs-fork call: Because it is small and abandoned, it is a reasonable template to fork internally if the team specifically wants a hand-rolled bus with full control — a decision about ownership cost, not about features.

When to Consider This Package

• You are on Symfony (not Laravel), want a minimal, no-frills CommandBus, and are prepared to vendor/fork it and own maintenance yourself.
• You need a teaching or reference artifact for a team learning the pattern before adopting a real bus.
• The scope is a throwaway prototype or internal tool where the 2021 freeze date and 0 dependents carry no business consequence.
• You explicitly want no framework coupling beyond Symfony's container, and are comfortable that handler wiring is your responsibility.

Look elsewhere when:

• You are on Laravel — the framework already ships a bus with queuing, middleware, and ShouldQueue; using a Symfony bundle here is pure friction.
• The work is production, long-lived, or customer-facing — an unmaintained dependency with no dependents is an unowned liability on your critical path.
• You need queues, retries, async transport, middleware, or observability — Symfony Messenger covers this and is maintained by the core team; League Tactician covers the synchronous case.
• Your team lacks DDD/CQRS fluency — an abandoned library plus an unfamiliar pattern compounds risk; adopt the pattern with a maintained library or not at all.
• Security, compliance, or auditability requires a provenance trail (SBOM, active CVE response) — this package cannot supply it.

How to Pitch It (Stakeholders)

To executives (one paragraph): We evaluated itmedia/command-bus-bundle, a small Symfony library implementing the CommandBus pattern. It has negligible adoption (3 stars, zero dependent projects) and has not been updated since September 2021, which means nobody is fixing bugs or security issues in it. The capability it provides — routing a command object to its handler — is a commodity already delivered by maintained framework tooling (Symfony Messenger, Laravel's native bus). Recommendation: do not adopt it as a dependency. We can implement the same pattern in-house in roughly a day if we want the discipline, or adopt a maintained library if we need queues and middleware. The only strategic value here is as a reference for scoping our own CQRS-lite work.

To engineering (summary): Treat this as a pattern reference, not a dependency. It is a Symfony bundle — irrelevant to a Laravel codebase without a bridge — and it is four years stale with no downstream users, so there is no community to absorb a breaking change or a CVE. If we want a bus, use Symfony Messenger (async, middleware, retries, first-party maintenance) or Laravel's Bus/dispatch(); if we want to own it, fork this as a starting template and accept that we own the code. Decision gate before any adoption: confirm framework, confirm whether async transport is in scope, and confirm who owns the fork.