Crate backbone_messaging 

Backbone Messaging - Event-driven messaging infrastructure

This crate provides a generic, type-safe event bus system for domain events following the Event-Driven Architecture and CQRS patterns.

Features

• Generic Event Bus: Type-safe publish/subscribe for any event type
• Event Envelope: Metadata wrapper with correlation/causation IDs
• Event Handlers: Async trait-based event handling
• Event History: Optional event persistence for replay
• Composite Events: Support for aggregate event streams
• Integration Events: Cross-bounded context communication (Phase 6)

Domain Events vs Integration Events

Aspect	Domain Event	Integration Event
Scope	Single bounded context	Cross-context
Types	Can use domain types	Primitives only (JSON)
Coupling	Internal	Loose coupling
Bus	EventBus<E> (typed)	IntegrationEventBus (type-erased)

Example - Domain Events

use backbone_messaging::{EventBus, EventHandler, DomainEvent};
use async_trait::async_trait;

// Define your domain event
#[derive(Clone, Debug)]
struct UserCreated {
    user_id: String,
    email: String,
}

impl DomainEvent for UserCreated {
    fn event_type(&self) -> &'static str { "UserCreated" }
    fn aggregate_id(&self) -> &str { &self.user_id }
}

// Create and use the event bus
let bus = EventBus::<UserCreated>::new();
bus.publish(UserCreated { user_id: "123".into(), email: "test@example.com".into() }).await?;

Example - Integration Events (Cross-Module)

use backbone_messaging::{IntegrationEventBus, IntegrationEvent, IntegrationEventHandler};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

// Define an integration event (must be serializable)
#[derive(Clone, Debug, Serialize, Deserialize)]
struct UserCreatedIntegrationEvent {
    user_id: String,
    email: String,
    occurred_at: DateTime<Utc>,
}

impl IntegrationEvent for UserCreatedIntegrationEvent {
    fn event_type(&self) -> &'static str { "sapiens.user.created" }
    fn source_context(&self) -> &'static str { "sapiens" }
    fn aggregate_id(&self) -> &str { &self.user_id }
    fn occurred_at(&self) -> DateTime<Utc> { self.occurred_at }
}

// Publish from Sapiens module
let bus = IntegrationEventBus::new();
bus.publish(UserCreatedIntegrationEvent { ... }).await?;

// Subscribe in Postman module (using wildcard pattern)
bus.register_handler(Arc::new(EmailHandler)).await; // patterns: ["sapiens.user.*"]

Re-exports

pub use crud_event::CrudEvent;

pub use crud_event::CrudEventPublisher;

pub use crud_event::NoOpCrudEventPublisher;

pub use noop::NoOpPublisher;

pub use noop::NoOpEventBus;

pub use noop::Publisher;

pub use subscriber::GenericEventSubscriber;

pub use subscriber::SubscriberCallback;

pub use subscriber::SubscriberRegistry;

Modules

crud_event

CRUD domain events — generic event types for all entity operations.

noop

No-op event publisher implementations.

prelude

Prelude module for convenient imports

subscriber

Generic event subscriber — reusable subscription wiring for any entity+event pair.

Structs

CollectingHandler

A handler that collects events for testing

DeadLetterEntry

Dead letter entry for failed event handling

EventBus

Generic event bus for publishing and subscribing to domain events

EventBusConfig

Configuration for the event bus

EventEnvelope

Wrapper for domain events with metadata

EventEnvelopeBuilder

Builder for creating event envelopes with metadata

IntegrationBusConfig

Configuration for the integration event bus

IntegrationEventBus

Central event bus for integration events across all bounded contexts

IntegrationEventEnvelope

Type-erased integration event envelope for cross-module transport

IntegrationLoggingHandler

A handler that logs all integration events

LoggingHandler

A handler that logs all events for debugging

Enums

EventError

Errors that can occur during event processing

Traits

DomainEvent

Trait for domain events

EventHandler

Trait for event handlers

IntegrationEvent

Trait for integration events that cross bounded context boundaries

IntegrationEventHandler

Pattern Matching