Sporteco/EventFly

EventFly is a .NET framework for building event-sourced, domain-driven applications using Akka.NET actors. It provides core infrastructure for managing aggregate state, orchestrating long-running sagas, and handling scheduled jobs, while supporting distributed deployments via Akka.Cluster. The system includes built-in capabilities for read-model projections, job scheduling, and external event integration, along with ASP.NET Core middleware for exposing commands and queries via REST and GraphQL.

The EventFly.Web package now provides an ASP.NET Core middleware pipeline that exposes commands and queries via HTTP. Users can configure a base path for the Web API (handling PUT for commands and POST for queries) and optionally enable GraphQL endpoints, a GraphQL Playground, and Swagger UI through dependency injection. The middleware is activated in the application pipeline by calling the new \UseEventFly\ extension method on \IApplicationBuilder\.

src/EventFly.Web · high confidence

Introduces a new RabbitMQ-based external event publisher for the EventFly framework. This includes the \RabbitMqEventPublisher\ class which handles publishing domain events to a configured RabbitMQ exchange with connection retry logic, message serialization via \RabbitMqMessageFactory\, and configuration support through \IRabbitMqEventPublisherConfiguration\. The implementation ensures reliable delivery by using publisher confirms and handles connection management with semaphore-based synchronization.

src/EventFly.RabbitMqEventPublisher · high confidence

The example API now includes a new Resource domain aggregate, consisting of the Resource aggregate root, a ResourceId identity value object, and a ResourceState class that applies the ResourceCreatedEvent. This adds the foundational domain model for managing resources within the event-sourced example.

examples/web/EventFly.Examples.Api/Domain/Aggregates/Resource · high confidence

The simple example now includes a complete UserAccount domain model, providing a concrete reference for implementing event-sourced aggregates. This addition introduces the UserAccountAggregate along with its supporting types: commands for creating an account and changing its name, domain events for these state changes, a dedicated identity type, and the aggregate state that applies the events to update the account name.

examples/simple/EventFly.Examples.Domain · high confidence

The EventFly.Infrastructure module now includes the core command models required for job scheduling. This adds the \Cancel\ command for stopping jobs, and three scheduling variants: \Schedule\ for one-time execution, \ScheduleRepeatedly\ for interval-based execution, and \ScheduleCron\ for cron-based execution. It also introduces the \Tick\ internal message used for scheduler timing and defines the \JobId\ type to serve as the unique identifier for jobs.

EventFly.Infrastructure · high confidence

The examples/jobs area now includes a complete sample application (EventFly.Examples.JobApplication) that demonstrates how to schedule, run, and cancel jobs using the EventFly infrastructure. This example defines a PrintJob with a corresponding runner and scheduler, registers them via dependency injection, and configures the job scheduler tick interval, providing a reference implementation for integrating scheduled background tasks.

examples/jobs/EventFly.Examples.Jobs · high confidence

The example API now includes a \ResourceCreationSaga\ that simulates a long-running resource creation process, emitting \ResourceCreationStartedEvent\, \ResourceCreationProgressEvent\, and \ResourceCreationEndedEvent\ to track progress. To support querying this state, the system introduces \OperationsProjection\ and \ResourcesProjection\ read models, along with their respective storage handlers (\OperationsStorageHandler\, \ResourcesStorageHandler\) and query handlers (\OperationsQueryHandler\, \ResourcesQueryHandler\). These components allow users to retrieve the current status and details of resource creation operations via the \IQueryOperations\ and \IQueryResources\ interfaces.

examples/web/EventFly.Examples.Api/Domain/Sagas · high confidence

A new ProjectService has been introduced in the User domain services to handle the creation and deletion of projects associated with a user. This service validates business rules using specifications (IsCanCreateProjectWithNameSpecification and IsCanDeleteProjectWithIdSpecification) before executing commands via the CommandBus and updating the UserAggregate, ensuring that project operations are performed only when valid.

examples/demo/Demo.Domain/User/Services · high confidence

The Demo.Application project now includes a new TestSaga class that serves as an example of implementing a stateless saga. This saga is triggered by the UserCreatedEvent and subsequently handles the UserRenamedEvent, illustrating how sagas can coordinate domain events within the application.

examples/demo/Demo.Application · high confidence

The EventFly library now includes an abstract base class, AbstractExternalEventProvider, which manages the routing of domain events to an internal event bus based on application definitions, and an IExternalEventPublisher interface that defines the contract for publishing domain events. This establishes the foundational components for integrating external event sources and publishers into the event flow.

src/EventFly.ExternalEventProvider, src/EventFly.ExternalEventPublisher · high confidence

The system now includes a command handler for the CreateResourceCommand, which processes requests to create new resource aggregates. When a user submits this command, the handler checks if the resource already exists; if it is new, it emits a ResourceCreatedEvent and returns a success result, otherwise it returns a failure indicating the aggregate is already created.

examples/web/EventFly.Examples.Api/Domain/Aggregates/Resource/Commands · high confidence

The application layer now includes a dedicated command handler for the DeleteProject operation. This handler processes the DeleteProjectCommand by invoking the ProjectService to remove the specified project from the user's account, returning a success or failure result based on the outcome.

examples/demo/Demo.Application/DeleteProject · high confidence

The EventFly.Extensions library now includes a new localization subsystem that allows values to be stored and serialized in multiple languages. This introduces a LanguageCode value object for validating culture names, a base LocalizedValueObject class for managing localized collections, and specific implementations for LocalizedString, LocalizedMarkdownString, LocalizedLink, and LocalizedImage. These components enable developers to define content (such as text, URLs, and image sources) that varies by language, with built-in JSON serialization support via Newtonsoft.Json.

EventFly.Extensions · high confidence

The Demo.Abstractions/Predicates area now includes a new set of abstract predicate classes and specific implementations for filtering. This adds support for querying collections (Any/All), dates (comparison operators), numeric values (Int32, Int64, Double, Decimal with range and equality checks), strings (case-insensitive Equals, Contains, StartsWith, EndsWith, OneOf), and geographic locations (distance-based filtering using great-circle distance). These abstractions provide the foundational logic for building complex filter expressions in the demo application.

examples/demo/Demo.Abstractions/Predicates · high confidence

A new domain service, UserTouchTrackingService, has been introduced to monitor user interactions. This service listens for UserNotesChangedEvent and automatically publishes a TrackUserTouchingCommand in response, enabling the system to track user touch activity as part of the demo domain logic.

examples/demo/Demo.Domain/Services · high confidence

The demo application now includes a dedicated command handler for creating projects, located in the CreateProject folder. This handler coordinates the creation process by invoking an external service and delegating the core logic to the domain's ProjectService, while also handling potential errors by returning a failed execution result. An interface for this external service (IExternalService) has also been added to support this workflow.

examples/demo/Demo.Application/CreateProject · high confidence

The EventFly Web API now automatically generates Swagger/OpenAPI documentation for domain Commands and Queries without requiring manual controller definitions. By registering the \CommandsApiDescriptionGroupCollectionProvider\, the framework introspects domain contexts to expose Commands as PUT endpoints and Queries as POST endpoints, complete with parameter descriptions and schema filtering.

src/EventFly.Web/Swagger · high confidence

The library now includes Entity Framework Core-based storage components. EntityFrameworkAggregateState provides a base class for managing aggregate state persistence, automatically saving changes to the database after each event is applied. EntityFrameworkReadModelStorage implements the read model storage interface, allowing read models to be loaded, saved, and queried using Entity Framework Core DbContext instances.

src/EventFly.Storages.EntityFramework · high confidence

The EventFly.Examples.Api project has been introduced as a new ASP.NET Core web application. It configures an Akka.NET ActorSystem and registers read-side query handlers (IQueryResources, IQueryOperations) for dependency injection. The API exposes endpoints under the /api route using MVC with compatibility set to .NET Core 2.1, and listens on port 5001.

examples/web/EventFly.Examples.Api · high confidence

This change introduces the EventFly.Clustering module, providing Akka.Cluster-based infrastructure for distributed deployments. It includes a ClusterParentProxy for message forwarding, ClusterFactory and SingletonFactory for managing sharded aggregates and singleton subscribers, and specific dispatchers (ShardedAggregateSagaDispatcher, SingletonDomainEventSubscriberDispatcher) to route domain events. The module also ships with default HOCON configuration for Akka Cluster and Sharding, along with type extensions to resolve event subscription types. Additionally, it adds initial example projects (EventFly.Examples.Application and EventFly.Examples.Api) demonstrating how to use these clustering features with aggregates and events.

examples/simple/EventFly.Examples.Application, examples/web/EventFly.Examples.Api/Domain/Aggregates/Resource/Events, src/EventFly.Clustering · high confidence

This change introduces the foundational abstractions for the EventFly framework within the \src/EventFly.Abstractions\ library. It defines the core domain-driven design contracts, including interfaces and base classes for Commands, Aggregates, Entities, and Domain Events. The diff adds the \ICommandBus\ interface for dispatching commands, \IExecutionResult\ types to handle success and failure outcomes, and metadata structures (\CommandMetadata\, \IEventMetadata\) for tracking correlation and source IDs. Additionally, it establishes versioning support via \VersionedTypeAttribute\ and its specialized \CommandVersionAttribute\ and \EventVersionAttribute\, along with core identity interfaces (\IIdentity\, \ISourceId\) and extension utilities.

src/EventFly.Abstractions · high confidence

The demo domain now includes a complete Project aggregate root that handles Create and Delete commands. This change adds the ProjectAggregate class implementing IExecute for both CreateCommand and DeleteCommand, along with corresponding CreateCommand, DeleteCommand, CreatedEvent, and DeletedEvent types. The aggregate manages project state through an IProjectState interface and emits domain events upon command execution, providing a foundational example of event-driven command processing within the demo application.

examples/demo/Demo.Domain/Project · high confidence

The API now exposes endpoints to create and query resources and operations. POST /api/resources creates a new resource and returns a 202 Accepted with Location and Content-Location headers pointing to the corresponding operation and resource URIs. GET /api/resources lists all resources or retrieves a specific one by ID. GET /api/operations lists all operations or retrieves a specific one, returning the operation details or a 303 See Other redirect to the resource endpoint once the operation is complete (100%).

examples/web/EventFly.Examples.Api/Controllers · high confidence

The EventFly framework now supports RabbitMQ as a transport for domain events. Users can register the provider via the \AddRabbitMqDomainEventProvider\ extension, configuring connection details, exchange, and queue names. The implementation includes a hosted service that manages the RabbitMQ connection lifecycle, handles message consumption, deserializes events, and publishes them to the internal domain event bus, with built-in retry logic for connection failures.

src/EventFly.RabbitMqEventProvider · high confidence

The demo domain now includes a new User aggregate that manages user lifecycle and project associations through an event-sourced model. The UserState class tracks user details (name, birth, notes) and a collection of associated projects, applying events such as UserCreated, UserRenamed, UserNotesChanged, and project creation/deletion events to update state. The UserAggregate root exposes commands for creating users, changing notes, tracking touches, renaming users, and creating or deleting projects, emitting corresponding domain events to drive state changes.

examples/demo/Demo.Domain/User · high confidence

The EventFly.Web/GraphQL package now provides a built-in mechanism to automatically expose application queries via GraphQL. By calling \ConfigureGraphQl\ on the \EventFlyBuilder\, the system registers a DI-based schema that introspects defined contexts and queries to generate corresponding GraphQL types, resolvers, and argument mappings (including support for arrays, nullable types, and standard .NET types like DateTime). This removes the need for manual GraphQL schema definition for standard read operations, allowing users to query their read models through a generated API endpoint.

src/EventFly.Web/GraphQL · high confidence

The demo infrastructure now provides concrete aggregate state classes for the Project domain, including a new in-memory implementation (ProjectStateInMemory) and an Entity Framework-backed implementation (ProjectState). These classes implement the IProjectState interface and handle event application for CreatedEvent and DeletedEvent, allowing the demo to persist and query project state either in memory or via a database context.

examples/demo/Demo.Infrastructure/AggregateStates · high confidence

The EventFly.Domain module introduces the core domain abstractions, including the AggregateRoot base classes and associated interfaces (IAggregateRoot, AggregateName). The implementation provides two distinct aggregate root types: EventSourcedAggregateRoot, which extends Akka.Persistence.ReceivePersistentActor to handle event sourcing and snapshotting, and EventDrivenAggregateRoot, which extends Akka.Actor.ReceiveActor for in-memory event-driven processing. This change establishes the foundational infrastructure for managing aggregate state, command handling, and event persistence within the EventFly framework.

EventFly.Domain · high confidence

The EventFly.Application layer now includes core infrastructure for saga-based workflows and scheduled jobs. This introduces the AggregateSaga base class and IAggregateSaga interface, enabling stateful, event-sourced sagas that can publish commands and manage their own persistence and snapshots via Akka.Persistence. It also adds a SagaLocatorByIdentity for resolving saga instances from event metadata, a SagaName value object, and new job identity types (PublishEventJobId, PublishCommandJobId) to support the newly moved scheduler interfaces, allowing the application to coordinate long-running processes and delayed event/command publishing.

EventFly.Application · high confidence

The EventFly.Abstractions package now exposes foundational identity and event types required for the domain model, including EventId, CommandId, SourceId, and JobName value objects, alongside the IDomainEvent interface hierarchy. Additionally, it introduces the PermissionCode and PermissionDefinition classes, establishing the basic building blocks for the system's permission and authorization capabilities.

EventFly.Abstractions · high confidence

The examples/cluster directory now includes a complete distributed cluster sample consisting of three new projects: EventFly.Examples.Seed (a seed node for Akka service discovery), EventFly.Examples.Worker (handles domain computation and aggregate processing), and EventFly.Examples.ClusterClient (interfaces with the cluster via a proxy). Each project includes its own HOCON configuration file (seed.conf, worker.conf, client.conf) and entry point, demonstrating how to distribute an EventFly domain across multiple nodes using Akka.Cluster without changing domain code.

examples/cluster · high confidence

A new demo host application has been added to demonstrate the EventFly framework integration with ASP.NET Core dependency injection. The application configures an EventFly instance with a specific context, initializes the actor system via the UseEventFly extension, and executes a sequence of commands (CreateUser, RenameUser, CreateProject, DeleteProject) through the ICommandBus to showcase command handling and result processing.

examples/demo/Demo.Host · high confidence

The project has adopted a new build infrastructure centered on FAKE (F\# Make) scripts and Azure Pipelines. This change introduces \build/build.fsx\ to orchestrate restore, build, test, SonarQube analysis, and package publishing, replacing previous build methods. It also adds Azure Pipelines YAML definitions (\azure-pipelines-development-ci-cd.yaml\, \azure-pipelines-master-ci-cd.yaml\, \azure-pipelines-release-ci-cd.yaml\, \azure-pipelines-static-ci.yaml\) to automate CI/CD workflows for development, master, and release branches, including support for SonarCloud quality gates and NuGet package pushes. Additionally, \Paket.Restore.targets\ is added to handle Paket dependency restoration within MSBuild.

build · high confidence

The EventFly.Application package now exposes a comprehensive set of interfaces and base classes that define how the framework handles asynchronous workflows and data projection. For sagas, it introduces ISaga, ISagaHandles, and ISagaIsStartedBy to declare event subscriptions, along with AggregateSagaManager to automatically locate, spawn, and supervise saga actors based on domain events. Read models are now managed via IReadModel, ReadModelManager, and ReadModelHandler, which subscribe to domain events and persist state changes through IReadModelStorage (including a built-in InMemoryReadModelStorage). Query handling is standardized with IQueryHandler, QueryManager, and a SerializedQueryExecutor for JSON-based query dispatch. Finally, job scheduling is abstracted through IJob, IJobRunner, and IScheduler, providing a contract for defining and executing scheduled background tasks.

src/EventFly.Application · high confidence

The test fixture library now includes base test kit classes (\EventFlyTestKit\, \AggregateTestKit\, \ContextTestKit\) that support registering custom dependencies via a delegate for easier mocking. It also introduces an aggregate fixture (\AggregateFixture\) with a BDD-style API (\Given\, \When\, \ThenExpect\) to arrange events, snapshots, and commands, and execute assertions with optional timeouts.

src/EventFly.TestFixture · high confidence

The EventFly.Extensions library now includes new abstractions to handle collection-level mutations within aggregates. Developers can use the new \ChangeValueObjectCollectionCommand\, \ChangeEntityCollectionCommand\, and \ChangeValueObjectWithCodeCollectionCommand\ to specify \AddOrUpdate\ and \Remove\ operations for collections. Corresponding event types (\ValueObjectCollectionChangedEvent\, etc.) are provided to apply these changes to the aggregate's state, automatically handling the addition of new items and the removal of existing ones based on identity or code.

src/EventFly.Extensions · high confidence

The EventFly.Domain module now provides the foundational building blocks for event-sourced aggregates. This includes the AggregateManager for routing commands to Akka-based aggregate actors, configurable settings for dead-letter handling and auto-dispatch, and a structured AggregateState that supports pre- and post-event application hooks. The diff also introduces comprehensive metadata models (EventMetadata, SnapshotMetadata) for tracking event and snapshot context, along with interfaces and value objects for committed events, snapshots, and transactional state.

src/EventFly.Domain · high confidence

The EventFly infrastructure layer has been restructured to support a modular architecture. Command execution now flows through a new \CommandToAggregateManagerBus\ that automatically validates commands using registered \ICommandValidator\ instances before dispatching to Akka actors. Actor naming and management are centralized in \DefinitionToManagerRegistry\, which registers managers for aggregates, queries, sagas, read models, and domain services with context-aware names. A new \EventFlyBuilder\ simplifies setup by auto-registering validators from assemblies and wiring up the DI resolver for Akka actors. Additionally, a robust job scheduling system is introduced, featuring \JobManager\ actors with backoff supervisors for runners and schedulers, along with definition classes for jobs and their lifecycle events.

src/EventFly.Infrastructure · high confidence

The demo application now includes query abstractions for retrieving event posters and user data. EventPostersQuery allows filtering events by various attributes such as title, type, organizer, and location using predicates, returning detailed poster information including media, partners, and competitions. Additionally, UsersQuery provides access to user information, with specific queries for retrieving individual user details by ID. These query definitions establish the interface for data retrieval in the demo's read model.

examples/demo/Demo.Abstractions/Queries · high confidence

The demo infrastructure now includes two new read models: TotalUsersReadModel, which maintains a running count of created users, and UsersInfoReadModel, which tracks user name and birth date changes. These models automatically apply domain events to keep the read-side data synchronized with user creation and renaming activities.

examples/demo/Demo.Infrastructure/ReadModels · high confidence

The demo application's User abstraction layer now includes a comprehensive set of command and event definitions to support user and project management. New commands allow users to be created (with validation and permissions), renamed, have their notes changed, and include a generic 'touch' tracking command. Project lifecycle is also modeled with commands to create and delete projects within a user's context. Corresponding domain events (UserCreated, UserRenamed, UserNotesChanged, UserTouched, ProjectCreated, ProjectDeleted) are introduced to capture these state changes. Additionally, a legacy interface (ISingleValueObject) from the core library was removed and replaced by the new TrackUserTouchingCommand, consolidating the demo's command structure.

examples/demo/Demo.Abstractions/User · high confidence

The project has been renamed from Akkatecture to EventFly, reflected in the new solution file (EventFly.sln) and updated project references. The solution structure has been reorganized into distinct folders (src, test, examples, build) and expanded to include new packages such as EventFly.Abstractions, EventFly.Domain, EventFly.Application, EventFly.Infrastructure, EventFly.Web, EventFly.Storages.EntityFramework, EventFly.TestFixture, EventFly.Extensions, and RabbitMQ providers. Additionally, a new demo example solution (Demo.\*) has been added, and the build system has been updated to use Azure Pipelines with FAKE scripts.

(repo-wide) · high confidence

The \Akkatecture.Core\ library has removed its foundational Domain-Driven Design building blocks, including the aggregate root and state management classes (\AggregateRoot\, \AggregateState\, \AggregateManager\), event and command interfaces (\IAggregateEvent\, \ICommand\, \IDomainEvent\), and supporting infrastructure such as metadata handling, saga definitions, and Akka actor typing utilities. This change eliminates the core implementation of the event sourcing and command handling architecture provided by this package.

src/Akkatecture.Core · high confidence

The standalone console application entry point (Program.cs) for the UserAccount example has been removed. This file previously contained the logic to initialize the Akka Actor system, create a UserAccountAggregateManager, and send a CreateUserAccountCommand, effectively serving as a manual demonstration of the event sourcing flow. Its deletion indicates that this specific standalone execution mode is no longer part of the example's structure.

examples/Akkatecture.Examples.UserAccount.Application · high confidence

The example project has removed the original UserAccountModel implementation, including the aggregate root, state, commands, events, and manager classes. This cleanup eliminates the previous event-sourcing structure for user accounts, likely to make way for a refactored or simplified domain model in the examples.

examples/Akkatecture.Examples.UserAccount · high confidence

The Demo.Infrastructure project has been completely reorganized to support the EventFly framework. A new UserContext class now centralizes dependency injection, registering aggregates (User, Project), commands, public events, sagas, and domain services. New query handlers (UsersQueryHandler, EventPostersQueryHandler) implement read-model queries, while a new PermissionProvider replaces the previous core EventId class to handle user permissions. Additionally, a DemoDbContext stub and an in-memory read model storage are introduced to support the demo's data layer.

examples/demo/Demo.Infrastructure · high confidence

The RenameUser command handler has been moved from the domain layer into the application layer (examples/demo/Demo.Application/RenameUser). This change separates application logic from domain logic, allowing the command handler to manage the execution flow while delegating the actual state change to the UserAggregate.

examples/demo/Demo.Application/RenameUser · high confidence

The Demo.Web project has been restructured as a standard ASP.NET Core web application, introducing a new Program.cs entry point and a Startup.cs configuration class. This setup integrates the EventFly framework via dependency injection, registering a 'user-example' context and configuring endpoints for GraphQL (/graphql), GraphQL Console (/graphql-console), Web API (/api-s), and Swagger (/swagger). The application is configured to use MVC Core with compatibility set to version 2.2 and includes standard launch settings for local development.

examples/demo/Demo.Web · high confidence

The Demo.Abstractions package now defines core identity value objects (UserId, ProjectId, EventPosterId) that inherit from EventFly's Identity base class and utilize SingleValueObjectConverter for JSON serialization. Additionally, a new DemoContextPermissions class has been added to centralize permission string constants (such as CreateUser and ChangeUser) for the demo application.

examples/demo/Demo.Abstractions · high confidence

The demo application's abstraction layer now includes specific domain value objects—Birth, UserName, and ProjectName—each equipped with built-in validation rules. Birth objects enforce that the date is not null and is in the past, while UserName objects require at least one localized string entry. ProjectName has been migrated from the core library to this demo location and renamed, maintaining its structure as a single-value object. These changes ensure that domain data integrity is enforced at the value object level within the demo context.

examples/demo/Demo.Abstractions/ValueObjects · high confidence

The demo application now includes domain logic to validate user actions regarding projects. A new \Project\ entity has been introduced to represent project data within the user's domain. Additionally, two new specifications enforce business rules: \IsCanCreateProjectWithNameSpecification\ prevents creating projects with duplicate names, and \IsCanDeleteProjectWithIdSpecification\ ensures that only existing, non-deleted projects can be deleted.

examples/demo/Demo.Domain/User/Entities, examples/demo/Demo.Domain/User/Specifications · high confidence

Added comprehensive unit tests for EventFly core abstractions and domain logic; Added test helper data models for commands, events, and jobs; Added test helper library for configuration, serialization, and categorization; Added unit tests for aggregate and domain service behavior.

The project now includes the dependency resolution manifest for the GraphQL.Server.Transports.AspNetCore library (version 1.0.0). This addition establishes the required runtime dependencies for GraphQL transport functionality within the AspNetCore environment, including specific versions for the core GraphQL library, ASP.NET Core hosting and HTTP abstractions, and supporting utilities like Newtonsoft.Json.

src/EventFly.Web/libs · high confidence

The project has been upgraded to target .NET Core 3.0 for executable projects (such as the Demo Host and test suites) and .NET Standard 2.0 for libraries, replacing the previous .NET Core 2.x targets. This migration includes upgrading the Akka.NET ecosystem to version 1.4.5 (including Akka.Cluster, Akka.Persistence, and Akka.TestKit) and updating Microsoft.Extensions.DependencyInjection to version 3.1.3. Additionally, the build system now utilizes Paket version 5.215.0 with FAKE 5.16.1 for dependency management and build automation.

(dependencies) · high confidence

Removed generated build artifacts and NuGet cache files from the Akkatecture.Tests project, including the deps.json, runtime config files, project.assets.json, and various obj/Debug cache files.

test/Akkatecture.Tests · high confidence

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

• CAI 50 → 49 (-1.0)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 47 → 39 (-8.0)
• Architecture 91 → 92 (+0.5)
• Maturity 57 → 57 (+0.0)
• Readiness 45 → 53 (+7.3)
• Security 60 → 59 (-0.3)
• Domain Modelling 56 → 66 (+9.9)
• Event-Driven 86 → 86 (+0.0)

• Bounded contexts not declared
• Change coupling: IFixtureArranger.cs ↔ IFixtureAsserter.cs (src/EventFly.TestFixture/Internals/AggregateFixture/IFixtureArranger.cs)
• Coverage not measured — analyzer environment
• Duplicated block (10 lines × 2) (src/EventFly.Domain/Aggregates/EventSourcedAggregateRoot.cs)
• Duplicated block (10 lines × 2) (src/EventFly.Domain/Subscribers/DomainEventSubscriber.cs)
• Duplicated block (11 lines × 2) (src/EventFly.Domain/Aggregates/EventSourcedAggregateRoot.cs)
• Duplicated block (11 lines × 2) (src/EventFly.Domain/Subscribers/DomainEventSubscriber.cs)
• Duplicated block (12 lines × 2) (src/EventFly.Domain/DomainService/AsynchronousDomainService.cs)
• Duplicated block (13 lines × 2) (src/EventFly.Domain/DomainService/AsynchronousDomainService.cs)
• Duplicated block (17 lines × 2) (src/EventFly.Domain/Aggregates/AggregateRoot.cs)
• Duplicated block (17 lines × 2) (src/EventFly.RabbitMqEventPublisher/ConnectionFactoryExtensions.cs)
• Duplicated block (5 lines × 4) (examples/demo/Demo.Abstractions/Predicates/NumericPredicate.cs)
• Duplicated block (7 lines × 4) (src/EventFly.Domain/DomainService/AsynchronousDomainService.cs)
• Duplicated block (9 lines × 2) (src/EventFly.Application/Queries/Consumer.cs)
• High CVE: Microsoft.NETCore.App 2.2.0
• High CVE: Microsoft.NETCore.App 2.2.0
• LLM evaluation failed
• Largest orphaned file (src/EventFly.Application/Sagas/AggregateSaga/AggregateSaga.cs)
• Largest orphaned file (src/EventFly.Domain/Aggregates/EventSourcedAggregateRoot.cs)
• Low cohesion: EventSourcedAggregateRoot (LCOM4 4) (src/EventFly.Domain/Aggregates/EventSourcedAggregateRoot.cs)
• …and 13 more

• Assertions commented out: TestDistinctCommand_AfterTwoHandles_CommandFails (test/EventFly.Tests/Domain/Aggregates/AggregateTests.cs)
• CommentedOutCode (test/EventFly.Tests/Application/Jobs/ScheduledJobsTests.cs)
• CommentedOutCode (test/EventFly.Tests/Domain/Aggregates/AggregateTests.cs)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (10 lines × 2) (src/EventFly.Application/Sagas/AggregateSaga/AggregateSagaManager.cs)
• Duplicated block (10 lines × 3) (src/EventFly.Domain/Subscribers/DomainEventSubscriber.cs)
• Duplicated block (11 lines × 2) (src/EventFly.Application/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (11 lines × 2) (src/EventFly.Application/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (11–12 lines × 3) (src/EventFly.Application/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (11–18 lines × 4) (src/EventFly.Application/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (12 lines × 2) (src/EventFly.Application/Queries/Consumer.cs)
• Duplicated block (12–19 lines × 4) (src/EventFly.Domain/Subscribers/DomainEventSubscriber.cs)
• Duplicated block (15 lines × 2) (src/EventFly.Application/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (15 lines × 2) (src/EventFly.Domain/DomainService/AsynchronousDomainService.cs)
• Duplicated block (15 lines × 2) (src/EventFly.Domain/Extensions/TypeExtensions.cs)
• Duplicated block (15–22 lines × 3) (src/EventFly.Application/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (16–17 lines × 3) (src/EventFly.Application/Extensions/TypeExtensions.cs)
• Duplicated block (17 lines × 3) (src/EventFly.Domain/Aggregates/AggregateRoot.cs)
• Duplicated block (18 lines × 2) (src/EventFly.RabbitMqEventProvider/ConnectionFactoryExtensions.cs)
• Duplicated block (20 lines × 2) (src/EventFly.Domain/Aggregates/AggregateRoot.cs)
• …and 48 more

• Unchanged — 5 HTTP endpoints

• Containers 0 added · 0 removed · contexts 2 added · 0 removed · edges 6 added · 0 removed

• EventFly.Extensions
• EventFly.Infrastructure

• EventFly.Extensions → EventFly.Abstractions
• EventFly.Infrastructure → EventFly.Abstractions
• EventFly.Infrastructure → EventFly.Application
• EventFly.Infrastructure → EventFly.Domain
• examples → EventFly.Extensions
• examples → EventFly.Infrastructure

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

Sporteco/EventFly 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.