Weave Code
Micro Service Reactor Laravel Package
micseres/micro-service-reactor
micseres/micro-service-reactor is a Laravel/PHP package for building reactive microservice workflows. It provides a lightweight reactor-style approach to coordinating service actions, events, and inter-service communication in PHP applications.
Micro Service Reactor is a lightweight Laravel package for coordinating reactions between microservices. It provides a simple abstraction for dispatching and handling service events, letting you wire cross-service triggers without scattering glue code across your application.
- Event-driven reactions — map incoming service events to local handlers
- Laravel-native — service provider, config publishing, and facade support
- Decoupled dispatch — keep microservice communication out of your domain logic
- Configurable endpoints — define target services and payloads declaratively
- Extensible — swap transports or add custom reactors via contracts
Ideal for teams splitting a monolith into services that still need to react to each other.
Frequently asked questions about Micro Service Reactor
- What is micseres/micro-service-reactor and what problem does it solve?
- It is a Laravel package for reactive microservice communication. It gives you a reactor API for dispatching events from one service and handling them in another, so services stay decoupled instead of calling each other directly. The goal is event-driven PHP applications with minimal setup and clean integration into existing Laravel projects.
- How do I install micseres/micro-service-reactor in a Laravel app?
- Install it with Composer using composer require micseres/micro-service-reactor. Most Laravel packages of this type register their service provider through package discovery, but you should confirm any manual provider registration or config publishing step in the repository README. After installing, check whether a config file needs to be published so you can point the reactor at your transport.
- Does it replace Laravel's built-in events, or work alongside them?
- The reactor API targets cross-service communication, so it sits alongside Laravel's native event dispatcher rather than replacing it. Local events and listeners still make sense for in-process work, while the reactor handles events that cross a service boundary. Keeping that split clear makes the codebase easier to reason about.
- Which Laravel and PHP versions are supported?
- The package is built for Laravel applications, but the exact Laravel and PHP version constraints live in its composer.json and README. Check those before adding it to an existing project, especially if you are on an older or very new Laravel release. Composer will also tell you immediately if your installed framework version conflicts.
- How do I dispatch an event to another microservice?
- You dispatch through the reactor API exposed by the package, passing the event payload your consuming service expects. The overview emphasises a simple reactor interface rather than raw broker clients, so transport details are abstracted away from the calling code. Refer to the README for the exact class names and method signatures.
- How do I handle incoming events from another service?
- Consumers register handlers that are invoked when a matching event arrives through the reactor. Because the point is decoupling, the producing service does not need to know which services consume its events. Consult the README for how handlers are registered, resolved, and discovered by the package.
- Do I need a message broker like Redis, RabbitMQ or Kafka to use it?
- The package overview does not mandate a specific broker, but reactive cross-service communication normally requires some transport such as a queue, Redis, or an HTTP endpoint. Confirm the supported transports in the package documentation before committing to infrastructure. If you already run Laravel queues, that is often the lowest-friction starting point.
- How should I test reactive event flows in a Laravel application?
- Test handlers as plain classes by invoking them with representative payloads, and use Laravel's testing helpers with a fake or in-memory transport to assert that events are dispatched. Payload contracts are the boundary between services, so cover their shape with tests as well. That keeps refactors safe without needing every service running locally.
- What production concerns come with this package, such as retries and duplicates?
- Distributed events raise questions about retries, duplicate delivery, ordering, and failure visibility. The package provides the communication layer, but you still need idempotent handlers, monitoring, and a retry or dead-letter strategy on the transport side. Plan those before going live rather than after the first lost event.
- How does it compare to Laravel's queue and event system or other messaging packages?
- Laravel's built-in events and queues cover many in-app cases, and heavier brokers or dedicated messaging packages handle high-volume needs. This package is a fit when you want a lightweight reactor abstraction over cross-service events without hand-wiring a broker client. Evaluate it against your existing queue setup and the transport you already operate.
Weaver
How can I help you explore Laravel packages today?