OnurGumus/FCQRS

FCQRS is an F\#-first event-sourcing and saga orchestration framework for .NET that provides infrastructure for defining aggregates, handling projections, and managing distributed workflows. It supports both F\# and C\# through type-safe models, serialization utilities, and interoperability layers, while leveraging Akka.NET for actor-based scheduling and state management. The system includes comprehensive tooling for testing, including virtual time simulation and Gherkin integration, alongside extensive documentation and runnable samples to guide implementation.

10 changes.

The project introduced the new FCQRS library, an F\#-first event-sourcing and saga framework featuring C\# interoperability, type-safe models, and advanced testing schedulers. Concurrently, the legacy CQRS infrastructure module was removed, and core dependencies were upgraded to .NET 10/11 to support the new architecture.

13 changes.

This period focused on expanding the FCQRS ecosystem with comprehensive documentation, automated verification scripts, and a wide array of runnable samples in both C\# and F\#. The work introduced new libraries for Gherkin-based testing and distributed tracing, alongside extensive test suites to validate core framework behaviors and data integrity.

A new C\# sample project has been added to demonstrate the FCQRS framework through a runnable document-store example. The sample includes a \DocumentAggregate\ for managing document state (creation, editing, and publication), a \SlugAggregate\ for slug reservation, and a \PublicationSaga\ that coordinates the publication workflow. It also provides a \LegacyCreationReader\ to adapt older event formats for backward compatibility, along with a \Program.cs\ entry point that supports CLI commands for creating, editing, publishing, and recovering documents, as well as a \--check\ mode to run pure domain, replay, and serialization verification tests.

samples/getting-started-csharp · high confidence

A new F\# sample project has been added to \samples/getting-started-fsharp\, providing a runnable document-store example for learning FCQRS. The project includes \Program.fs\ for the main application logic (handling commands like create, edit, and publish via CLI arguments) and \Checks.fs\ for pure domain, replay, and serialization verification. A \README.md\ documents how to build and run the sample using the .NET 10 SDK, including instructions for checking state, recovering documents, and testing publication workflows.

samples/getting-started-fsharp · high confidence

A new sample file (Account.fs) has been added to the registration-fsharp directory, demonstrating a Command-Query Responsibility Segregation (FCQRS) pattern in F\#. This example defines a RegisterUser command and a UserRegistered event, along with logic to persist the user's name if no state exists and to fold events into the current state, serving as a runnable reference for developers learning this architecture.

Registration.FSharp · high confidence

New sample projects have been added for C\# and F\# that demonstrate how to use FCQRS 6.12.0 to register a user. These samples include the aggregate logic, a projection to query the registered name, and a host setup using SQLite for persistence, allowing developers to run and learn from the code directly.

samples/registration-csharp, samples/registration-fsharp · high confidence

FCQRS 6.15.0 adds ShiftedScheduler, which uses Akka.NET's default scheduler with a configurable time shift to advance real time in tests. This allows tests to simulate days passing while keeping timers, command timeouts, saga handshakes, and cluster sharding behavior aligned with production, unlike virtual clocks that cannot support these real-time interactions.

(repo-wide) · high confidence

The FCQRS library has been significantly refactored to support modern .NET development, including an upgrade to .NET 9 and the introduction of a new C\# interoperability layer (CSharpInterop.fs) that provides fluent registration builders, delegate types, and value-creation helpers for C\# consumers. A new AkkaTimeProvider replaces standard .NET timers with Akka.NET scheduler-backed timers, enabling precise virtual-time control for testing and ensuring BCL-compliant timer behavior. Additionally, the library now includes HostExtensions for simplified dependency injection integration, a transactional ProjectionStorage for SQL-based projection catch-up, and improved query subscription mechanisms with auto-publishing and filtering capabilities.

src/FCQRS · high confidence

This change introduces the foundational structure for the FCQRS documentation site, including the configuration file that defines the site name, navigation, and project references. It adds the initial documentation content, featuring a step-by-step tutorial for building a small bank application (covering opening accounts, withdrawing money, transferring funds, and viewing statements) and how-to guides for core concepts like defining aggregates, adding projections, handling async effects, and testing domain logic.

.livedocs · high confidence

The FCQRS.ExpectoTickSpec library now provides a bridge between TickSpec and Expecto, allowing users to run Gherkin feature files as Expecto tests. Feature files are loaded as embedded resources from the caller's assembly, and scenarios are grouped by Gherkin \Rule:\ tags into nested test lists. Test execution behavior is controlled via Gherkin tags: \@focus\ marks tests as focused (running only those tests), while \@pending\ marks them as pending (skipped but reported). A legacy underscore prefix on feature or scenario names also enables focusing. The library caches step definitions per assembly to optimize performance and handles pending features by building them from source without binding steps, preventing failures when step implementations are not yet available.

src/FCQRS.ExpectoTickSpec · high confidence

This release adds the FCQRS library, providing a complete event-sourcing and saga orchestration framework for .NET with first-class F\# support. It introduces idiomatic F\# functional wrappers (FCQRS.FSharp) for defining aggregates, sagas, and projections, alongside core infrastructure for distributed tracing, transactional journal-wide projections, and robust saga start handshakes. The framework includes built-in event upcasting for schema evolution, conditional command handling with version conflicts, and resilient projection catch-up with configurable backoff and full-scan intervals.

FCQRS · high confidence

Adds the FCQRS.Model library, introducing type-safe value types such as CID, ShortString, LongString, and AggregateId that enforce validation rules (e.g., CID cannot contain '\~') and provide an IsValid check. It also includes a validation framework with regex-based checks for emails and URLs, and interfaces for messages carrying Correlation IDs.

FCQRS.Model · high confidence

The saga\_sample now demonstrates a user registration flow where a saga handles the verification code generation and email notification. This change adds a new UserSaga that reacts to User.VerificationRequested events, generates a code, and sends a mail via a side-effect actor, while also integrating distributed tracing (ActivitySource/SerilogTracing) and Hocon configuration for the scheduler.

_saga\sample · high confidence

The new FCQRS.Model library provides core functional programming primitives for the FCQRS ecosystem, including a comprehensive set of optics (Lens, Prism, Isomorphism, Epimorphism) with support for validation and asynchronous setters. It introduces a Free Monad implementation with a dedicated computation expression builder that seamlessly handles Result types for error propagation. Additionally, the package includes C\# interoperability helpers to simplify consuming FCQRS types from C\# projects, offering factory methods and try-create patterns for string types.

src/FCQRS.Model · high confidence

A new F\# sample project has been added to guide beginners through the FCQRS library. It provides a runnable example implementing a document management workflow with publication capabilities, including the core domain models (commands, events, and state handling) and a saga implementation that coordinates slug reservation and publication result reporting.

GettingStarted.FSharp · high confidence

Added a five-step C\# and F\# learning path in the samples/accounts directory that demonstrates core FCQRS capabilities: opening accounts and handling deposits (step 1), enforcing business rules for withdrawals and rejecting invalid commands (step 2), configuring snapshot policies to optimize state reconstruction on restart (step 3), building a transactional SQL projection to maintain a read-model statement table from the event journal (step 4), and implementing a saga-driven money transfer between accounts with idempotency and refund handling (step 5).

samples/accounts · high confidence

Added a suite of Python scripts to automate the building, checking, and verification of the project's documentation and learning samples. The \build-docs.py\ script converts literate F\# scripts to Markdown, integrates with FsLiveDocs, and uses Pagefind for search indexing. New verification scripts ensure documentation integrity: \check-doc-links.py\ validates local links and fragments, \check-doc-tooltips.py\ ensures compiler tooltips are present on F\# examples, and \check-learning-snippets.py\ synchronizes tutorial excerpts with runnable sample code. Additionally, \check-accounts.py\, \check-accounts-http.py\, \check-learning-path.py\, and \check-registration.py\ execute and validate the behavior of specific tutorial samples (accounts, HTTP endpoints, learning paths, and registration) to guarantee that the documented examples remain correct and runnable.

scripts · high confidence

A new sample application has been added to the 'sample' directory, providing a complete reference implementation for the FCQRS library. This sample introduces a User aggregate with registration and login capabilities, wired up with a SQLite query side and a command-side actor system. A key feature of this sample is the integration of distributed tracing: it configures Serilog with SerilogTracing and Seq, and demonstrates how to propagate W3C traceparent identifiers via command correlation IDs to link command execution with query-side projection events. The sample includes bootstrap logic, environment wrappers, and a program entry point that exercises these tracing flows.

sample · high confidence

The FCQRS.Serialization module now round-trips C\# 15 discriminated unions via a new \UnionConverterFactory\ that writes a \$case\ discriminator and \$value\ payload. This enables users to serialize and deserialize C\# union types without losing case information, while also enforcing C\# nullable annotations during (de)serialization.

FCQRS.Serialization · high confidence

The CQRS module has been removed from the codebase. This deletes the core implementation files for the Command Query Responsibility Segregation pattern, including the Akka-based Actor logic for handling sagas and events (Actor.fs), common type definitions for commands, events, and saga starters (Common.fs), query subscription and read-journal integration (Query.fs), and the System.Text.Json-based serialization adapter (Serialization.fs).

src/CQRS · high confidence

The SQL provider's query augmentation logic has been corrected to handle sorting and pagination correctly. Secondary sorting (thenBy/thenByDesc) now properly chains onto primary sorting within the same query expression, preventing the ArgumentException that occurred when previous query shapes were rejected. Additionally, pagination now applies Skip before Take, ensuring correct OFFSET/FETCH behavior instead of the previous inverted composition that returned incorrect result sets.

src/FCQRS.SQLProvider · high confidence

Added Facade.Tests to verify core FCQRS behaviors; New test suite for bank invariant, serialization, and projection subscription correctness.

The serialization module now references the FSharp.SystemTextJson package, enabling JSON serialization capabilities for F\# types using System.Text.Json.

src/FCQRS.Serialization · high confidence

The documentation examples, sample applications, and core FCQRS libraries now target .NET 10 (with some samples using .NET 11), replacing the previous .NET 8 baseline. This update aligns the project with the latest .NET runtime and includes corresponding dependency upgrades, such as Akka.NET moving from 1.5.28 to 1.5.59 and Akkling from 0.16.2 to 0.17.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 53 → 51 (-1.5)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 92 → 77 (-15.3)
• Architecture 94 → 100 (+6.0)
• Maturity 80 → 80 (-0.1)
• Readiness 55 → 55 (+0.0)
• Security 33 → 32 (-0.9)

• Documentation: written for insiders (docs/how-to/index.md)
• Duplicated block (13 lines × 2) (saga_sample/Query.fs)
• Duplicated block (6 lines × 2) (src/FCQRS/Actor.fs)
• Internal.actorProp (cognitive 40) (src/FCQRS/Common.fs)
• Internal.actorProp (cyclomatic 27) (src/FCQRS/Common.fs)
• Low XML-doc coverage: Registration.Http.CSharp (samples/registration-http-csharp/Registration.Http.CSharp.csproj)
• Projections.start (cognitive 57) (src/FCQRS/Projections.fs)
• Projections.start (cyclomatic 48) (src/FCQRS/Projections.fs)
• Scattered collaborators
• Two distinct types appear to represent the same concept (a publication that has completed), but are named with inverted word order: 'PublicationFinished' vs 'FinishedPublication'.
• Two types ending in 'Uncertain' likely represent similar state or result concepts (one for reporting, one for reservation). While the prefixes differ, the shared suffix suggests a potential inconsistency in how uncertainty states are modeled or named across the domain.
• redundant comment (samples/getting-started-csharp/Checks.cs)
• redundant comment (samples/registration-csharp/Program.cs)

• Documentation: no architecture or design documentation (README.md)
• Documentation: no usage examples (docs/index.html)
• Duplicated block (10 lines × 2) (samples/accounts/5-transfer-money/fsharp/Account.fs)
• Duplicated block (10–13 lines × 2) (samples/accounts/5-transfer-money/fsharp/Program.fs)
• Duplicated block (11 lines × 2) (samples/accounts/5-transfer-money/csharp/Transfer.cs)
• Duplicated block (12 lines × 3) (samples/accounts/2-withdraw-money/csharp/Account.cs)
• Duplicated block (12–22 lines × 2) (scripts/check-accounts.py)
• Duplicated block (13 lines × 2) (saga_sample/Query.fs)
• Duplicated block (13 lines × 2) (samples/accounts/1-open-an-account/fsharp/Program.fs)
• Duplicated block (13 lines × 2) (samples/accounts/5-transfer-money/csharp/Transfer.cs)
• Duplicated block (14 lines × 2) (samples/accounts/5-transfer-money/fsharp/Transfer.fs)
• Duplicated block (15 lines × 2) (samples/accounts/1-open-an-account/csharp/Program.cs)
• Duplicated block (18 lines × 2) (samples/accounts/5-transfer-money/csharp/Account.cs)
• Duplicated block (18 lines × 3) (samples/accounts/2-withdraw-money/fsharp/Account.fs)
• Duplicated block (19 lines × 2) (samples/accounts/1-open-an-account/fsharp/Program.fs)
• Duplicated block (19 lines × 3) (samples/accounts/4-show-a-statement/fsharp/Program.fs)
• Duplicated block (22 lines × 2) (samples/accounts/4-show-a-statement/csharp/Statement.cs)
• Duplicated block (22–23 lines × 2) (samples/accounts/2-withdraw-money/fsharp/Program.fs)
• Duplicated block (23 lines × 2) (samples/accounts/4-show-a-statement/fsharp/Statement.fs)
• Duplicated block (23 lines × 2) (samples/accounts/5-transfer-money/fsharp/Transfer.fs)
• …and 39 more

• 39 commits — 38 feature/other, 1 fixes

• (root) — 15 commits
• samples/accounts — 11 commits
• src/FCQRS — 8 commits
• test/Facade.Tests — 2 commits
• docs/concepts — 1 commit
• samples/getting-started-csharp — 1 commit
• src/FCQRS.Serialization — 1 commit

• fix: [fe] Release gap-proof projections and the saga recovery fix in FCQRS 6.12.0
• change: [docs] Explain when and why FCQRS stops the process
• change: [docs] State that FCQRS runs on one node
• change: [fe] Add ShiftedScheduler: a moved Now on real-time timers, in FCQRS 6.15.0
• change: [fe] Apply each projection pass in journal order
• change: [fe] Carry commands to other nodes and test the bank under process kills
• change: [fe] Give C# sagas their own start member and inferred registration in FCQRS 6.10.0
• change: [fe] Leave the CID separator check to FCQRS.Model
• change: [fe] Let C# 15 unions drive aggregates and sagas in FCQRS 6.7.0
• change: [fe] Let CRUD developers learn FCQRS by building a small bank
• change: [fe] Read only recent writes in each projection pass
• change: [fe] Refuse a saga start that its correlation ID already used
• change: [fe] Reject '~' however a CID is created
• change: [fe] Release incremental projection queries in FCQRS 6.13.0
• change: [fe] Release journal-order projection passes in FCQRS 6.14.0
• change: [fe] Release the CID separator check in FCQRS.Model 6.1.0
• change: [fe] Release the FCQRS.Model 6.1.0 requirement in FCQRS 6.13.1
• change: [fe] Release the saga-start refusal in FCQRS 6.11.0
• change: [fe] Run the bank invariant test on PostgreSQL in CI
• change: [fe] Run the learning path on published FCQRS 6.10.0
• …and 19 more

• 3 added · 1 removed (a removed endpoint is potentially breaking)

• GET /accounts/{id}/statement
• POST /accounts/{id}/deposits
• POST /accounts/{id}/withdrawals

• GET /accounts/{id}

• Containers 1 added · 0 removed · contexts 0 added · 1 removed · edges 0 added · 0 removed

• database:Database

• Registration.Http.FSharp

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

OnurGumus/FCQRS was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.