EventCore

Multi-stream event sourcing with dynamic consistency boundaries

Why EventCore?

Traditional event sourcing forces you to choose aggregate boundaries upfront, leading to complex workarounds when business logic spans multiple aggregates. EventCore eliminates this constraint with dynamic consistency boundaries - each command defines exactly which streams it needs, enabling atomic operations across multiple event streams.

🚀 Key Features

Quick Example

#![allow(unused)]
fn main() {
use eventcore::prelude::*;

#[derive(Command)]
#[command(event = "BankingEvent")]
struct TransferMoney {
    from_account: AccountId,
    to_account: AccountId,
    amount: Money,
}

impl TransferMoney {
    fn read_streams(&self) -> Vec<StreamId> {
        vec![
            self.from_account.stream_id(),
            self.to_account.stream_id(),
        ]
    }
}

#[async_trait]
impl CommandLogic for TransferMoney {
    type State = BankingState;
    type Event = BankingEvent;

    async fn handle(
        &self,
        _: ReadStreams<Self::StreamSet>,
        state: Self::State,
        _: &mut StreamResolver,
    ) -> CommandResult<Vec<StreamWrite<Self::StreamSet, Self::Event>>> {
        // Validate business rules
        require!(state.balance(&self.from_account) >= self.amount,
            "Insufficient funds"
        );

        // Emit events - atomically written to both streams
        Ok(vec![
            emit!(self.from_account.stream_id(), 
                BankingEvent::Withdrawn { amount: self.amount }
            ),
            emit!(self.to_account.stream_id(),
                BankingEvent::Deposited { amount: self.amount }
            ),
        ])
    }
}
}

Getting Started

Use Cases

EventCore excels in domains where business operations naturally span multiple entities:

• 💰 Financial Systems: Atomic transfers, double-entry bookkeeping, complex trading operations
• 🛒 E-Commerce: Order fulfillment, inventory management, distributed transactions
• 🏢 Enterprise Applications: Workflow engines, approval processes, resource allocation
• 🎮 Gaming: Player interactions, economy systems, real-time state synchronization
• 📊 Analytics Platforms: Event-driven architectures, audit trails, temporal queries

Performance

Community

Join our growing community of developers building event-sourced systems:

• 📖 Comprehensive Documentation
• 🐛 Report Issues
• 🤝 Contributing Guide

Resources

• GitHub Repository
• crates.io Package
• API Documentation

Supported By