Weave Code
Code Weaver
Helps Laravel developers discover, compare, and choose open-source packages. See popularity, security, maintainers, and scores at a glance to make better decisions.
Feedback
Share your thoughts, report bugs, or suggest improvements.
Subject
Message

Eventsauce Bundle Laravel Package

andreo/eventsauce-bundle

View on GitHub
Deep Wiki
Context7

Product Decisions This Supports

  • Event-Driven Architecture (EDA) Adoption:

    • Enables seamless integration of EventSauce (a CQRS/ES library) into Symfony, reducing friction for teams already using Symfony’s ecosystem.
    • Supports decoupled microservices by leveraging Symfony Messenger for async event dispatching, aligning with modern distributed systems.
  • Roadmap: Scalable Event Sourcing:

    • Build vs. Buy: Avoids reinventing event sourcing infrastructure (e.g., custom Doctrine repositories, message dispatchers) by providing a batteries-included bundle.
    • Use Cases:
      • Audit trails (e.g., financial transactions, healthcare records).
      • Real-time projections (e.g., dashboards, notifications).
      • Complex domain modeling (e.g., DDD aggregates with snapshotting).
  • Anti-Corruption Layer (ACL) for Legacy Systems:

    • Facilitates gradual migration of monolithic apps to event-driven architectures by translating legacy events into domain events.
    • Reduces coupling between bounded contexts via message filtering/translation.
  • Performance Optimizations:

    • Snapshotting: Mitigates performance degradation in large event streams by storing aggregate state periodically.
    • Message Outbox: Ensures reliable event delivery with retries/backoff strategies (e.g., for external APIs).
  • Developer Experience (DX):

    • Convention over Configuration: Attributes (e.g., @AsSyncMessageConsumer) reduce boilerplate for event consumers.
    • Symfony Integration: Leverages existing tools (Messenger, Doctrine) without context-switching.

When to Consider This Package

  • Adopt When:

    • Your team is already using Symfony 6.2+ and needs event sourcing without vendor lock-in.
    • You require CQRS/ES patterns but want to avoid low-level implementation (e.g., manual event storage, message dispatching).
    • You need ACL, snapshotting, or outbox patterns for reliability/scalability.
    • Your architecture involves microservices or event-driven workflows (e.g., order processing, IoT telemetry).
  • Look Elsewhere If:

    • You’re not using Symfony: This bundle is tightly coupled to Symfony’s ecosystem (Messenger, Doctrine).
    • You need real-time event processing: EventSauce is not a streaming platform (e.g., Kafka, Pulsar). Use it for persistent event storage, not pub/sub.
    • Your team lacks event-sourcing expertise: The package abstracts complexity but requires understanding of aggregates, events, and projections.
    • You need high-throughput event processing: EventSauce’s synchronous dispatchers may bottleneck under extreme load (consider async workers or message brokers).
    • You’re using PHP <8.2: Hard dependency on PHP 8.2+ features (e.g., attributes, enums).

How to Pitch It (Stakeholders)

For Executives:

"This bundle lets us adopt event-driven architecture without building custom infrastructure. By integrating EventSauce into Symfony, we can:

  • Decouple services for easier scaling (e.g., separate read/write models).
  • Audit everything (e.g., financial transactions, user actions) via event logs.
  • Future-proof our system for microservices or real-time features with minimal rework. It’s a low-risk bet—we’re leveraging battle-tested libraries (EventSauce, Symfony Messenger) while reducing dev time by 30%+ on event-sourcing plumbing."

For Engineers:

"This bundle gives us Symfony-native event sourcing with zero trade-offs:

  • Out of the box: Doctrine event store, Messenger integration, ACL, snapshotting—all configurable via YAML/attributes.
  • Flexible dispatching: Sync (for projections) or async (via Messenger) consumers. Supports retries, backoff, and outbox patterns for reliability.
  • DDD-friendly: Snapshots for performance, upcasters for schema evolution, and decorators for cross-cutting concerns. Example use case: Replace our current CRUD + triggers with event-sourced aggregates for orders, then build real-time dashboards by projecting events. Zero lock-in—we can migrate to other ES libraries later if needed."*

For Architects:

"Key advantages for our stack:

  1. Symfony Alignment: Uses existing tools (Doctrine, Messenger) without introducing new dependencies.
  2. Resilience: Outbox pattern + retries handle transient failures (e.g., external API calls).
  3. Scalability: Snapshotting reduces load on event stores; ACL isolates legacy systems.
  4. Observability: All events are stored in a single table per aggregate, simplifying debugging. Trade-offs: Not ideal for ultra-low-latency systems (add async workers if needed). Requires discipline around event design (e.g., avoiding anemic domain models)."*
Weaver

How can I help you explore Laravel packages today?

Conversation history is not saved when not logged in.
Prompt
Add packages to context
No packages found.
comsave/common
alecsammon/php-raml-parser
chrome-php/wrench
lendable/composer-license-checker
typhoon/reflection
mesilov/moneyphp-percentage
mike42/gfx-php
bookdown/themes
aura/view
aura/html
aura/cli
povils/phpmnd
nayjest/manipulator
omnipay/tests
psr-mock/http-message-implementation
psr-mock/http-factory-implementation
psr-mock/http-client-implementation
voku/email-check
voku/urlify
rtheunissen/guzzle-log-middleware