Watermill is a Go library for building message-driven and event-driven applications. It is not a standalone service; applications embed it and use the core Publisher/Subscriber interfaces to communicate with brokers such as Kafka, RabbitMQ, NATS, Redis Streams, Google Cloud Pub/Sub, AWS SNS/SQS, SQL databases, or an in-memory Go channel. This repository contains the core library, reusable components, runnable examples, and small CLI tools, while broker-specific adapters and some integrations live in separate modules. The architecture is layered. At the bottom are the low-level Pub/Sub abstractions and the Message object with UUID metadata, payload, and Ack/Nack lifecycle semantics. The middle layer is the Router, which wires handlers into consumption loops and supports middleware and publisher/subscriber decorators. On top of that, optional components implement CQRS event/command buses and processors, topic forwarding, request-reply, delayed publishing, metrics, fan-in/fan-out, and requeuing. Middleware covers retry with exponential backoff, poison queues, deduplication, throttling, circuit breaking, correlation IDs, timeout enforcement, and panic recovery. The repository is extensively tested, including a universal pub/sub conformance suite intended for adapter authors to reuse, and GoChannel serves as a complete in-memory reference implementation. The examples demonstrate real production patterns: CQRS with protobuf, ordered events, exactly-once delivery counters, outbox/transactional event forwarding, server-sent event feeds, webhook ingestion, and consumer groups. There is no data research component; this is purely a software library/application framework.
This repository is the **Wow** framework, a comprehensive, production-grade event-sourcing and CQRS framework for building reactive, cloud-native applications in Kotlin and Java. It provides a full stack: domain modeling with aggregates, commands, events, and sagas; reactive command/event buses with multiple backends (MongoDB, Redis, Elasticsearch, Kafka); a query gateway with rich filter DSL and snapshot/event-stream queries; automatic OpenAPI generation; a compensation subsystem with a React dashboard for managing failed executions and retries; observability via OpenTelemetry; and BI tooling for ClickHouse. The architecture is modular (30+ Gradle modules) but deployable as separate services (e.g., compensation server, example server). It is actively developed with extensive tests (unit, contract, integration, JMH benchmarks) and comprehensive documentation.
Emmett is a TypeScript monorepo providing an opinionated event sourcing and CQRS framework for Node.js applications. It implements the decider pattern for business logic, with pluggable event store backends (PostgreSQL, SQLite, MongoDB, EventStoreDB, in-memory) and web framework integrations (Express, Hono, Fastify). The framework includes built-in projections (single/multi-stream, raw SQL, document-oriented via Pongo), consumer/processor pipelines with checkpointing and locking, workflow orchestration, and comprehensive observability via OpenTelemetry (tracing, metrics, logging). The codebase is modular with separate packages per database and web framework, extensive test coverage (unit, integration, e2e), and a CLI for schema migrations. It is actively maintained with a large community (539 stars, 53 forks) and zero dependabot alerts. The architecture demonstrates high craftsmanship with reusable patterns for middleware composition, streaming transformations, and BDD-style testing specifications.
PrestaShop is a full-featured open-source e-commerce platform written in PHP, built on Symfony for the back-office and modern JavaScript/TypeScript for the admin interface. The codebase follows Domain-Driven Design (DDD) with a CQRS pattern, separating commands and queries into dedicated handlers. It provides a complete e-commerce backend including product, order, customer, carrier, tax, and shipping management, along with a powerful grid system, import/export engine, multi-shop and multi-language support, and an OAuth2-secured API. The architecture is a monolith with a modular domain layer, an adapter layer bridging legacy ObjectModel code, and a Symfony bundle layer for controllers, forms, and security. The admin theme uses Vue.js components and a custom grid framework with extensible columns, filters, and actions. Despite active modernization, the codebase retains significant legacy code (jQuery plugins, Smarty templates, deprecated interfaces) and exhibits a mixed architecture that introduces maintenance overhead. The repository is the core of the PrestaShop ecosystem, with a large community and extensive CI/CD pipelines.
Equinox is an F# library for event-sourced systems, providing a consistent abstraction over multiple stream-based storage backends including CosmosDB, DynamoDB, EventStoreDB, MessageDB, SqlStreamStore, and an in-memory store. In production, it enables applications to define domain logic as pure decision functions that produce events, while the library manages optimistic concurrency, caching, snapshots, and retries. The core is the `Decider` pattern: an aggregate loaded from a stream, a decide function that returns events, and a fold that applies events to produce new state. Access strategies (e.g., `LatestKnownEvent`, `RollingSnapshots`, `Custom`) control how state is reconstructed from stored events, trading read cost for write cost. The architecture is modular: the `Equinox` package defines the core interfaces (`ICategory`, `IStream`, `Decider`), while separate NuGet packages implement storage adapters. The library is used as a dependency in larger applications; sample projects (`Store/Domain`, `TodoBackend`, `Tutorial`) demonstrate its use. Key entry points include the `Decider` class for command/query execution, `Category` for resolving streams, and store-specific connectors (e.g., `CosmosStoreConnector`, `DynamoStoreConnector`). A CLI tool (`Equinox.Tool`) provides provisioning, benchmarking, and data inspection commands across all stores. External dependencies are minimal per package: `Equinox` depends only on `FsCodec` for serialization; store adapters require their respective SDKs (Azure.Cosmos, AWSSDK.DynamoDBv2, EventStore.Client, Npgsql, etc.). The library includes comprehensive caching (`Equinox.Cache` wrapping `System.Runtime.Caching.MemoryCache`), metrics via Prometheus, and a load testing harness. Despite some deprecated adapters (legacy EventStore TCP, SqlStreamStore) and high complexity from multiple backends, the core patterns are clean, well-tested, and production-proven at Jet.com.
PipelinR is a lightweight Java library implementing the mediator/pipeline pattern for command processing. It provides a type-safe way to send commands to handlers through a configurable pipeline of middleware, supporting cross-cutting concerns like logging, validation, and transactions. The library also implements notification (event publishing) with multiple handling strategies including synchronous, asynchronous, and parallel execution modes. With zero dependencies and a focus on simplicity, it aims to help developers follow SOLID principles by replacing monolithic service classes with focused handlers.
This repository is a comprehensive educational course titled '.NET Web API Zero to Hero' by codewithmukesh. It contains over 50 independent ASP.NET Core Web API sample projects organized into modules covering fundamentals (minimal APIs, exception handling, logging), database management with EF Core (CRUD, migrations, interceptors, soft deletes, bulk operations, pagination), advanced API patterns (CQRS with MediatR, custom dispatcher, Result pattern, mapping benchmarks), performance and caching (in-memory, Redis, HybridCache, EF second-level cache), API security (JWT, refresh tokens, role/claims/policy/permission-based authorization, API keys, CORS, rate limiting), file handling (PDF invoice generation), architecture (Clean Architecture vs Vertical Slice), observability (health checks, structured logging), and background processing. Each sample is a self-contained, runnable project with minimal setup (often using in-memory databases) and includes extensive BenchmarkDotNet performance comparisons. The code is well-structured, follows modern .NET 10 patterns, and demonstrates production-quality implementations of cross-cutting concerns like global exception handling, validation pipelines, and caching strategies. While the repo is primarily a teaching resource, many components (custom CQRS dispatcher, Result pattern, EF Core interceptors, permission-based authorization) are genuinely reusable in other projects.