DOCSEARCHbyAlgolia
Submit Docs

Eventuous

website·Indexed 32 days ago

https://eventuous.dev

A lightweight library for building event-sourced systems with CQRS, available for .NET and Go. It provides tools for domain modeling with aggregates, event persistence, and real-time subscriptions, with infrastructure support for KurrentDB, Apache Kafka, RabbitMQ, Google PubSub, Azure Service Bus, PostgreSQL, MongoDB, and Microsoft SQL Server.

Tokens
152K
Snippets
573
Records
893
Agent score
55%

What's inside Eventuous

  1. Overview of Eventuous SignalR Gateway

    The SignalR subscription gateway bridges Eventuous stream subscriptions to SignalR, enabling real-time event streaming to remote clients. It consists of two primary components:

    • Eventuous.SignalR.Server: A server-side gateway that manages per-connection Eventuous subscriptions and forwards events.
    • Eventuous.SignalR.Client: A client-side API providing auto-reconnect and typed event handling.

    The server utilizes the GatewayHandler and BaseProducer patterns, ensuring that event forwarding maintains the same tracing and metadata pipeline as other Eventuous producers.

  2. Overview of the Eventuous Consume Pipe

    The consume pipe is a sequence of filters (similar to middleware) that process messages after they are received from a transport. When a subscription receives a message, it creates a consume context (containing the message, ID, type, and subscription ID) and passes it through the pipe. Filters are executed sequentially; each filter can modify the context or decide whether to pass it to the next filter. The process completes when no filters remain, marking the message as consumed.

  3. Overview of Eventuous diagnostics and OpenTelemetry

    Eventuous provides built-in metrics and traces for the event store, subscriptions, consumers, event handlers, command services, and producers. These diagnostics are integrated with OpenTelemetry via the OpenTelemetry .NET library.

  4. Overview of Eventuous Go

    Eventuous Go is a production-grade Event Sourcing library for Go, ported from the .NET Eventuous library. It implements the full Event Sourcing lifecycle, including domain modeling (events, state, aggregates), command handling, persistence with optimistic concurrency, real-time subscriptions for projections, and OpenTelemetry observability.

  5. Overview of the Eventuous Event Store abstraction

    Eventuous uses the IEventStore abstraction to decouple the core library from specific event storage implementations. IEventStore inherits from IEventReader (for reading events from streams) and IEventWriter (for appending events to streams). This separation allows components to depend only on the specific capability they require.

    Available implementations include:

    • KurrentDBEventStore: The default implementation using KurrentDB.
    • In-memory event store: Used primarily for testing; provides no persistence guarantees and is not recommended for production.

  6. Overview of the IEventStore abstraction

    Eventuous uses the IEventStore abstraction to decouple the core library from specific event storage implementations. IEventStore inherits from IEventReader (for reading events from streams) and IEventWriter (for appending events to streams). This separation allows components to depend only on the specific capability they require.

    Available implementations include:

    • KurrentDBEventStore: The default implementation using KurrentDB.
    • In-memory event store: Used primarily for testing; provides no persistence guarantees and is not recommended for production.

  7. Overview of Eventuous for .NET

    Eventuous is a lightweight library designed for building production-grade applications using the Event Sourcing pattern. It provides abstractions based on Domain-Driven Design (DDD) tactical patterns, such as the Aggregate. Key capabilities include aggregate persistence, real-time subscriptions, command services, observability via OpenTelemetry, and integration with ASP.NET Core.

  8. Overview of Eventuous for .NET

    Eventuous is an open-source library (Apache 2.0 license) designed to implement Event Sourcing in .NET applications. It provides a structured framework to avoid the labor and common failures associated with building custom event sourcing infrastructure from scratch. The library covers key architectural areas including domain model aggregates, event persistence, application services, and event processing subscriptions (such as read models).

  9. Overview of Eventuous for .NET

    Eventuous is a lightweight library designed for building production-grade applications using the Event Sourcing pattern. It provides abstractions based on Domain-Driven Design (DDD) tactical patterns, such as the Aggregate. Key capabilities include aggregate persistence, real-time subscriptions, command services, Open Telemetry observability, and integration with ASP.NET Core.

  10. Overview of Eventuous SignalR Gateway

    The SignalR subscription gateway bridges Eventuous stream subscriptions to SignalR, enabling real-time event streaming to remote clients. It utilizes the Gateway pattern (GatewayHandler + BaseProducer) to ensure event forwarding maintains the same tracing and metadata pipeline as other Eventuous producers.

    Available packages:

    • Eventuous.SignalR.Server: Server-side gateway that manages per-connection subscriptions and forwards events.
    • Eventuous.SignalR.Client: Client-side API featuring auto-reconnect and typed event handling.

  11. Overview of Eventuous for Event Sourcing

    Eventuous is an open-source .NET library designed to implement Event Sourcing without the labor and risk associated with building a custom framework from scratch. It provides a structured approach to domain modeling, event persistence, and asynchronous event processing.

  12. Overview of the Functional Command Service concept

    The functional command service is an alternative to using aggregates for domain models. Instead of stateful aggregates, it uses stateless functions that receive a restored state instance and a collection of previously stored events to produce new events.

    The service follows these steps when handling a command:

    1. Extracts the stream name from the command.
    2. Instantiates necessary value objects (rejecting the command if construction fails).
    3. Loads stream events from the Event Store if the command operates on an existing stream.
    4. Restores state from the loaded events.
    5. Executes the operation using the state, events, and command values.
    6. Produces new events or rejects the operation.
    7. Persists new events to the store upon success, or returns a failure to the edge.