revoframework/Revo
48.0
Weak · 8 November 2026
26.9k
lines of production code
C#
primary language
7
measurements over time
What this system is
Features
ASP.NET Core security module implementation
The ASP.NET Core security module now provides an \IUserContext\ implementation (\AspNetCoreUserContext\) that resolves the current user and their permissions by leveraging \IHttpContextAccessor\ and \IClaimsPrincipalUserResolver\. This module registers the user context in the task scope, enabling the framework to identify authenticated users and retrieve their permissions within ASP.NET Core applications.
Providers/AspNetCore/Revo.AspNetCore/Security · high confidence
Added FakeUserContext for testing security scenarios
A new FakeUserContext class has been added to the Revo.Testing.Security namespace to facilitate unit testing of security-related code. This class implements the IUserContext interface, allowing developers to inject a fake user and a list of permissions into their tests. It provides methods to set up a fake user with a generated ID and username, and exposes properties to check authentication status and retrieve user details, simplifying the setup of test environments that depend on user context.
Revo.Testing/Security · high confidence
Added NSubstitute-based spy decorator for testing
The Revo.Testing library now includes a SubstituteDecorator utility that wraps an existing object instance with an NSubstitute spy. This allows users to intercept calls on existing objects during tests without needing to replace the instance entirely, facilitating easier mocking of dependencies that are already instantiated.
Revo.Testing, Revo.Testing/Extensions · high confidence
Added SQL baseline migration scripts for History, Event Store, and Async Queues
This change introduces explicit SQL baseline migration scripts for the Revo infrastructure, supporting MSSQL, PostgreSQL, and SQLite. The new files define the initial schema for the History extension (tracked change records and entity attribute data) and the core infrastructure components: the Event Store (event streams and rows), Async Event Queues (queues, external event records, and queued events), and Saga Metadata. These scripts provide the database structure required for these features to operate on the supported SQL providers.
Extensions/Revo.Extensions.History/Sql, Revo.Infrastructure/Sql · high confidence
Automatic data annotation validation for commands
The Revo.Infrastructure module now automatically validates command objects using standard .NET data annotations (System.ComponentModel.DataAnnotations) before they are processed. This is achieved by introducing a new CommandAttributeValidationFilter that implements IPreCommandFilter, which is registered as a singleton via the ValidationInfrastructureModule. If validation fails, a new CommandValidationException is thrown. Additionally, the project structure has been adjusted to expose internal types to the test assembly and for mocking purposes.
Revo.Infrastructure/Properties, Revo.Infrastructure/Validation · high confidence
Command authorization and entity query filtering
This change introduces a new security layer for commands in the Revo infrastructure. It adds attributes (\AuthenticatedAttribute\, \AuthorizePermissionsAttribute\) to mark commands as requiring authentication or specific permissions. A \CommandPermissionCache\ discovers these attributes at startup to enforce access control via \CommandPermissionAuthorizer\. Additionally, it implements \EntityQueryAuthorizer\ and \IEntityQueryFilter\ interfaces, allowing developers to define filters that restrict the results of entity queries based on the current command context.
Revo.Infrastructure/Security/Commands · high confidence
Enable ASP.NET Core integration via configuration section
Users can now activate the ASP.NET Core provider by calling the \UseAspNetCore\ extension method on \IRevoConfiguration\. This registers the \AspNetCoreModule\ and \AspNetCoreSecurityModule\ within the dependency injection kernel, provided the \AspNetCoreConfigurationSection\ is marked as active.
Providers/AspNetCore/Revo.AspNetCore/Configuration · high confidence
Hangfire provider integration for background job processing
The Hangfire provider is now available to replace the in-memory job scheduler for background task execution. Users can enable this via the \UseHangfire\ configuration extension, which registers the \HangfireJobScheduler\ and \HangfireModule\ within the DI container. The implementation supports immediate job enqueuing, scheduled execution, and recurring jobs via cron expressions. Configuration is managed through \HangfireConfigurationSection\, allowing customization of the job storage, background server options, and additional processes, with the dashboard disabled by default.
Providers/Hangfire · high confidence
Initial ASP.NET Core integration with Hangfire and environment support
This release introduces the first version of ASP.NET Core support for the Revo framework. It adds an \AspNetCoreEnvironmentProvider\ to map the application environment, a \UserActorContext\ to bridge ASP.NET Core user identity with Revo's actor system, and a new \IAspNetCoreStartupConfigurer\ interface for extensible startup logic. Additionally, it integrates Hangfire for background job processing, including a custom \HangfireJobActivator\ that resolves jobs via the Ninject DI container, configurable storage and server options, and a dashboard that is disabled by default.
Providers/AspNetCore/Revo.AspNetCore/Core · high confidence
Initial ASP.NET Core integration with request-scoped DI and custom activators
The Revo framework now supports ASP.NET Core via the new Revo.AspNetCore provider. This integration introduces a \RevoStartup\ base class that initializes the Ninject kernel and registers core services, including custom activators for MVC controllers, SignalR hubs, and view components to ensure they are resolved through the DI container. It also implements request-scoped lifetime management for dependencies, ensuring that objects registered in the task context are deterministically disposed at the end of the HTTP request, and provides middleware to manage the request scope lifecycle.
Providers/AspNetCore/Revo.AspNetCore · high confidence
Initial Entity Framework 6 provider implementation
This release introduces the Entity Framework 6 (EF6) provider for the Revo framework, enabling users to use EF6 as their primary data access technology. The change adds a complete set of configuration extensions (UseAllEF6Infrastructure, UseEF6DataAccess, etc.) to wire up EF6-specific modules for repositories, event stores, projections, and sagas. It includes the core data access layer (EF6CrudRepository, EF6DatabaseAccess, DbContextFactory) and an in-memory repository implementation for testing, allowing applications to persist and query data using EF6 while maintaining the framework's existing abstractions.
Providers/EF6/Revo.EF6 · high confidence
Initial Entity Framework Core provider support
The framework now includes a new Entity Framework Core provider for data access, event storage, and projections. This addition introduces configuration extensions (UseAllEFCoreInfrastructure) to wire up EF Core repositories, the event store, sagas, and async event handling, alongside a convention system for model mapping (e.g., snake\_case naming, table prefixes). It also provides a dedicated migration provider to handle schema updates within the framework's transactional context.
Providers/EFCore · high confidence
Introduce Revo.EasyNetQ module for RabbitMQ event integration
This change adds the Revo.EasyNetQ module, providing a new integration layer with RabbitMQ via the EasyNetQ library. It introduces configuration extensions (UseEasyNetQ) to set up connections, subscriptions, and event transports, and registers core components like BusInitializer, EasyNetQBus, and subscription handlers. A key behavioral addition is support for blocking subscriptions, allowing events to be processed sequentially to ensure ordering, alongside the standard concurrent processing model. The module also includes a NullEasyNetQBus for scenarios where the integration is inactive.
Providers/EasyNetQ/Revo.EasyNetQ · high confidence
Introduce tenant-owned base classes and read models
This change adds a set of new base classes and interfaces in the Tenancy domain to support tenant-owned resources. Specifically, it introduces \ITenantOwned\ to mark resources with a \TenantId\, and provides tenant-aware variants for aggregate roots (\TenantBasicAggregateRoot\, \TenantBasicClassAggregateRoot\, \TenantEventSourcedAggregateRoot\) and read models (\TenantReadModelBase\, \TenantEntityReadModel\, \TenantClassEntityReadModel\, \TenantEntityView\). The \TenantEventSourcedAggregateRoot\ automatically publishes a \TenantAggregateRootCreated\ event upon instantiation, ensuring the tenant context is captured in the event stream.
Revo.Domain/Tenancy · high confidence
Introduced buffered notification channel with configurable buffering and release policies
The notification system now supports buffering, allowing notifications to be collected and released in batches rather than sent immediately. This location implements the core buffering infrastructure, including the \BufferingNotificationChannel\ for capturing notifications, the \BufferedNotificationStore\ for persisting them, and the \AggregatingBufferGovernor\ which determines when buffered notifications are ready to be released based on a configurable time delay. A background job (\ProcessBufferedNotificationsJob\) periodically processes these buffers, grouping them by pipeline and dispatching them, ensuring that notifications can be aggregated for efficiency.
Extensions/Revo.Extensions.Notifications/Channels/Buffering · high confidence
Introduction of Domain Core Module and Exception Type
The Revo.Domain/Core area now includes a new Ninject module (DomainCoreModule) that registers core domain services, specifically binding IEntityTypeManager and various convention caches to their implementations within the task scope. Additionally, a new DomainException class has been added to provide a specific exception type for domain-related errors.
Revo.Domain/Core · high confidence
Introduction of basic entity and aggregate root base classes for RDBMS persistence
New base classes have been added to the domain layer to support entities persisted via ORM to relational databases. This includes \BasicEntity\ and \BasicAggregateRoot\ which implement \IQueryableEntity\ and \IRowVersioned\ for standard database operations, as well as \BasicClassEntity\ and \BasicClassAggregateRoot\ which add support for a \ClassId\ property to facilitate type discrimination in RDBMS storage.
Revo.Domain/Entities/Basic · high confidence
Introduction of event-sourced aggregate root and component base classes
This change introduces the core infrastructure for event-sourced entities within the domain model. New classes \EventSourcedAggregateRoot\, \EventSourcedComponent\, and \EventSourcedEntity\ are added, enabling aggregates to manage state through published events rather than direct property mutations. The \EventSourcedAggregateRoot\ implements a \Commit\ method that increments the aggregate version by one per commit (rather than by event count) and provides a \LoadState\ method to reconstruct state from an \AggregateState\ snapshot. These classes rely on convention-based discovery of \Apply\ methods to handle event application internally.
Revo.Domain/Entities/EventSourcing · high confidence
Introduction of the Revo.Extensions.Notations module
The Revo.Extensions.Notifications module has been introduced to provide a structured notification system. It defines core interfaces (INotification, INotificationBus, INotificationChannel) and implementations for pushing notifications to various channels, serializing them via JSON, and caching notification types. The module includes a NotificationBus that routes notifications to appropriate channels based on type, a NotificationSerializer using Newtonsoft.Json with camel-case naming, and a NotificationTypeCache that discovers all INotification implementations. It also registers background jobs for processing buffered notifications and sending mail, and integrates with the database migration system.
Extensions/Revo.Extensions.Notifications · high confidence
New ADO.NET database migration provider with multi-dialect support
This location introduces a new extensible database migration system for ADO.NET-based providers, enabling schema version management independent of Entity Framework. It adds the \AdoNetDatabaseMigrationProvider\ and its abstract base \AdoNetStubDatabaseMigrationProvider\ to handle migration execution, including support for isolated or non-transactional migration modes and event hooks (e.g., \DatabaseMigrationBeforeAppliedEvent\). The diff also adds dialect-specific scripters for SQL Server (\MssqlMigrationScripter\), PostgreSQL (\PgsqlMigrationScripter\), and SQLite (\SqliteMigrationScripter\), along with the generic \GenericSqlDatabaseMigrationScripter\ and \DatabaseMigrationRecord\ model, allowing users to apply SQL migrations to these databases using a unified provider interface.
Revo.Infrastructure/DataAccess/Migrations/Providers · high confidence
New CommandApiController base class for ASP.NET Core
A new abstract CommandApiController class has been added to the Revo.AspNetCore.Web namespace, providing a base controller for ASP.NET Core applications. This controller exposes injected ICommandBus and ICommandGateway properties, enabling derived controllers to easily access command handling infrastructure.
Providers/AspNetCore/Revo.AspNetCore/Web · high confidence
New LambdaCommandBusExtensions for executing lambdas as commands
Added new extension methods on ICommandBus (SendLambdaCommandAsync) that allow executing arbitrary lambda functions as if they were regular command handlers, including scoped dependency resolution and unit of work commitment. This is supported by new LambdaCommand, LambdaResultCommand, and LambdaCommandHandler classes that wrap delegates and invoke them with resolved service locator parameters.
Revo.Core/Commands/Lambda · high confidence
New Revo.Rebus provider for asynchronous event publishing
The Revo.Rebus module now provides a new integration for publishing domain events via the Rebus service bus. This change introduces a new event listener (RebusEventListener) that collects events and publishes them asynchronously through Rebus, along with the necessary command handlers and unit-of-work management to ensure events are processed correctly within the Rebus pipeline. Configuration is now handled via code-based extensions (UseRebus) rather than XML, allowing users to wire up Rebus as their async event transport mechanism.
Providers/Rebus · high confidence
New Todos sample application added
A new sample application demonstrating the Revo framework's capabilities has been added. It features a todo-list management UI with an ASP.NET Core API, event-sourced domain models (TodoList, Todo), and a CQRS architecture using command and query handlers. The app includes read-model projections, database migration scripts for SQL Server, PostgreSQL, and SQLite, and uses AutoMapper for DTO mapping.
Examples/Todos/Revo.Examples.Todos · high confidence
New ValueObject base class and collection wrappers in Revo.Core
The Revo.Core.ValueObjects namespace now includes a new abstract ValueObject\<T\> base class that provides value-based equality, hashing, and string representation for domain models. To support complex state, the update adds wrapper classes (ListAsValue, SetAsValue, DictionaryAsValue) and extension methods (AsValueObject) that allow immutable collections to be correctly compared as value components. Additionally, a SingleValueObject\<T, TValue\> class and its associated JSON converter are introduced to simplify the creation and serialization of value objects that wrap a single underlying value.
Revo.Core/ValueObjects · high confidence
New application lifecycle hooks and task-scoped dependency injection
The framework now exposes explicit application lifecycle events (Starting, Started, Stopping) via new listener interfaces, allowing components to hook into the startup and shutdown phases. Additionally, a new task-context mechanism using AsyncLocal enables fine-grained dependency injection scoping for asynchronous operations, ensuring that services registered in a task scope are correctly resolved and disposed across async boundaries.
Revo.Core/Core · high confidence
New change-tracking data models for history extension
The History extension now includes specific domain models to store change tracking data: \EntityAttributeData\ for managing attribute value maps via JSON serialization, and \TrackedChangeRecord\ for recording individual change events with actor, aggregate, and entity identifiers. These classes define the schema structure for the history feature, utilizing specific table and column prefixes for database mapping.
Extensions/Revo.Extensions.History/ChangeTracking/Model · high confidence
New collection utilities and logging helper in Revo.Core
The Revo.Core.Collections namespace now includes a custom MultiValueDictionary\<TKey, TValue\> implementation to replace the deprecated corefxlab version, providing methods to add ranges from IGrouping and key-value pairs. Additionally, a new Extensions class adds an AsNotNull\<T\> method to safely handle null enumerables and a ToSeparatedString helper, while Revo.Core.Logging introduces a GenericLoggerFactory to create strongly-typed ILogger instances from an ILoggerFactory.
Revo.Core/Collections · high confidence
New database migration system with automatic startup execution
This location introduces the core infrastructure for a new database schema versioning system, including the \DatabaseMigrationExecutor\ and \DatabaseMigrationSelector\ to discover, validate, and apply migrations based on module dependencies and environment tags. A new \DatabaseMigrationExecutionHook\ implements \IApplicationStartingListener\ to automatically apply pending migrations at application startup in development mode, ensuring the database schema is kept in sync without manual intervention.
Revo.Infrastructure/DataAccess/Migrations · high confidence
New entity attribute change tracking in History extension
The Revo.Extensions.History module now includes a ChangeTracking subsystem that records granular attribute-level changes on entities. This adds a new \ChangeData\ hierarchy (including \EntityAttributeChangeData\<T\>\) to model specific value changes, an \EntityAttributeChangeLogger\ that detects old vs. new values and batches them, and a \ChangeTracker\ that persists these changes as \TrackedChangeRecord\ entities and publishes \TrackedChangeAdded\ events. The feature is wired via \HistoryModule\ using Ninject, leverages AutoMapper for mapping between records and domain objects, and registers a \ChangeDataTypeCache\ to resolve change data types at application startup.
Extensions/Revo.Extensions.History/ChangeTracking · high confidence
New entity model and repository abstractions for ASP.NET Core/EF Core support
The Revo.DataAccess.Entities namespace now provides the foundational types required for the new ASP.NET Core and EF Core data access layer. This includes new repository interfaces (IReadRepository, ICrudRepository, IFilteringRepository) that define methods for entity retrieval, modification, and filtering, alongside an IAsyncQueryableResolver to abstract database query execution. The update introduces entity state tracking (EntityState), concurrency control interfaces (IRowVersioned, IManuallyRowVersioned), and specific exception types (EntityNotFoundException, OptimisticConcurrencyException). Additionally, new attributes (DatabaseEntityAttribute, TablePrefixAttribute) and helper utilities (EntityExpressionUtils, RepositoryHelpers) are added to support entity configuration and expression building.
Revo.DataAccess/Entities · high confidence
New event message infrastructure and metadata handling in Revo.Core.Events
The Revo.Core.Events namespace now includes a complete set of new types for event messaging and metadata management. This introduces the IEventBus and PublishEventBuffer for asynchronous event dispatching, along with IEventMessage, IEventMessageDraft, and their implementations to support building and cloning event messages with metadata. Metadata handling is enhanced with new classes: BasicEventMetadataNames (moved from a previous location), FilteringMetadata, LayeredMetadata, and JsonMetadata, which provide flexible ways to manage, filter, and store event metadata. The EventBus implementation uses reflection to discover and invoke IEventListener handlers for published events.
Revo.Core/Events · high confidence
New event serialization and message factory infrastructure
The Revo.Infrastructure/Events module now introduces dedicated interfaces and implementations for event serialization and message creation. Users benefit from a new EventSerializer that handles JSON serialization with customizable settings and camel-case naming, and an EventMessageFactory that constructs event messages by applying metadata from registered providers. These components are wired into the DI container via EventsModule, providing the underlying mechanics for event storage and retrieval.
Revo.Infrastructure/Events · high confidence
New in-memory job scheduler infrastructure
This location introduces a new in-memory job scheduling system, providing the interfaces (IInMemoryJobScheduler, IInMemoryJobSchedulerProcess, IInMemoryJobWorkerProcess) and concrete implementations (InMemoryJobScheduler, InMemoryJobSchedulerProcess, InMemoryJobWorkerProcess) that handle job enqueuing, scheduled execution, and worker parallelism. It includes configuration support via InMemoryJobsConfigurationSection and InMemoryJobsConfigurationExtensions, allowing users to enable or disable the in-memory scheduler and tune retry attempts, timeouts, and worker parallelism through the application's configuration kernel.
Revo.Infrastructure/Jobs/InMemory · high confidence
New job scheduling and command execution infrastructure
The Revo.Infrastructure/Jobs module now provides a complete system for enqueuing, scheduling, and executing background jobs. Users can dispatch commands asynchronously via EnqueueJobCommand (with optional delay) or ScheduleJobCommand (for specific times), which are handled by the job scheduler. The system introduces a generic job execution pipeline where ExecuteCommandJob wraps commands and ExecuteCommandJobHandler dispatches them through the ICommandGateway, ensuring commands are processed in the background. Recurring job support is also available via the IJobScheduler interface.
Revo.Infrastructure/Jobs · high confidence
New standalone Revo Database Migrator tool with isolated assembly loading and multi-provider support
A new standalone CLI tool, Revo.Tools.DatabaseMigrator (invokable as \revo-dbmigrate\), is introduced to manage database migrations independently of the main application. It supports Npgsql, SqlServer, and SQLite providers and allows users to specify migrations via assembly references or directory paths. To prevent library version clashes, the tool loads assemblies in an isolated environment using PluginManager. Users can preview pending changes or execute upgrades, filtering by module names (including wildcards) and environment tags.
Tools · high confidence
New testing helpers for event-sourced entities
The Revo.Testing.Infrastructure namespace now includes new extension methods and helper classes to simplify testing event-sourced aggregates. EventExtensions provides ToMessageDraft for creating event message drafts and ToAggregateEventMessages for converting sequences of domain events into message drafts with automatic metadata (such as stream sequence numbers, aggregate class IDs, and timestamps). EventSourcedEntityTestingHelpers adds AssertEvents, AssertAllEvents, and AssertConstructorEvents methods that allow developers to verify the events generated by an aggregate root, including support for custom event assertions and handling of constructor-replayed events. Additionally, a FakeEventStoreRecord class is provided to represent event store records in tests.
Revo.Testing/Infrastructure · high confidence
New unified type versioning system
This change introduces a new type versioning system in Revo.Core/Types, allowing types to be explicitly versioned via the new TypeVersionAttribute or implicitly by appending a 'V' followed by a number to the type name (e.g., MyTypeV2). The system includes a TypeExplorer for scanning assemblies, a TypeIndexer to identify and parse these versions, and a VersionedTypeRegistry to manage and retrieve versioned types by ID, CLR type, or name. This enables the framework to handle multiple versions of the same logical type, supporting scenarios like event sourcing or polymorphic deserialization where type evolution is required.
Revo.Core/Types · high confidence
On-the-fly event stream upgrades via IEventUpgrade
The Revo infrastructure now supports automatic event stream migration when loading aggregates. By implementing the IEventUpgrade interface, developers can define logic to transform or replace historical events, which the system applies dynamically during aggregate loading. This feature includes helper extensions for replacing or removing specific event types, a base class for aggregate-specific upgrades, and automatic discovery of upgrade implementations via dependency injection.
Revo.Infrastructure/Events/Upgrades · high confidence
RavenDB projection subsystem and automatic projector discovery
The RavenDB provider now includes a dedicated projection subsystem that automatically discovers and registers event projectors implementing IRavenEntityEventProjector. This change introduces RavenProjectionSubSystem to handle projector execution and persistence via the RavenDB repository, and RavenProjectionEventListener to manage async event dispatching with correct tenant context. The feature is controlled by the AutoDiscoverProjectors configuration option, which enables automatic registration of projectors via RavenProjectorDiscovery.
Providers/RavenDB/Revo.RavenDB/Projections · high confidence
Saga metadata storage and retrieval via dedicated repository
The saga infrastructure now supports persisting and querying arbitrary key-value metadata associated with saga instances. New entity models (SagaMetadataRecord, SagaMetadataKey) and a SagaMetadataRepository have been introduced to manage this data, enabling sagas to store and retrieve metadata keys for identification and correlation purposes.
Revo.Infrastructure/Sagas/Generic · high confidence
Security infrastructure module initializes authorization and permission caching
The security infrastructure now registers core authorization components via a new Ninject module. Entity query authorizers and filter factories are bound with task-scoped lifetimes to ensure proper disposal, while the command permission cache is registered as a singleton. Additionally, a pre-command filter is registered to authorize commands before execution, establishing the foundation for command-level security checks.
Revo.Infrastructure/Security · high confidence
Behavioural changes
AutoMapper integration refactored into dedicated extension package
The automatic registration of AutoMapper profiles has been moved from the core framework into the new Revo.Extensions.AutoMapper package. This change introduces a modular initialization process where profiles are discovered and registered via Ninject, and allows users to apply custom configuration through an optional action passed to the AddAutoMapperExtension method.
Extensions/Revo.Extensions.AutoMapper · high confidence
Centralized infrastructure configuration via new extension methods
The Revo.Infrastructure package now provides a unified entry point for configuring core infrastructure services through the new \ConfigureInfrastructure\ extension method and \InfrastructureConfigurationSection\. This change consolidates the setup of in-memory job scheduling, async event pipeline settings, database migration modules, tenancy configuration, and optional saga support into a single, structured configuration block, replacing previous scattered registration patterns.
Revo.Infrastructure · high confidence
Enhanced multi-tenancy isolation and command context support
The tenancy infrastructure now enforces stricter data isolation by default: null (unauthenticated) tenants can no longer access other tenants' data, a behavior controlled by the new \NullTenantCanAccessOtherTenantsData\ configuration flag. The system introduces a new \ITenantContext\ and \ITenantContextResolver\ abstraction to manage the current tenant, allowing commands to explicitly override the tenant context via \CommandExecutionOptions\ through the new \TenantContextCommandBusMiddleware\. Additionally, the \TenantRepositoryFilter\ now uses a lazy-loaded context to ensure proper filtering application from the first request, and a new \InTenantSingletonScope\ Ninject extension enables tenant-scoped dependency lifetimes.
Revo.Infrastructure/Tenancy · high confidence
EntityDto now implements IHasId\<Guid\>
The base EntityDto class now implements the IHasId\<Guid\> interface, standardizing how entity identifiers are exposed across the domain layer. This change ensures that all DTOs inheriting from EntityDto explicitly conform to a consistent identity contract, simplifying usage for consumers that rely on this interface for entity resolution or mapping.
Revo.Domain/Dto · high confidence
Explicit configuration registration for History and Notifications extensions
The History and Notifications extensions now require explicit registration via new configuration extension methods (\AddHistoryExtension\ and \AddNotificationsExtension\). Users must call these methods to enable the respective features, as the extensions no longer register themselves automatically. The History extension allows toggling change tracking via the \IsChangeTrackingActive\ flag, while the Notifications extension is enabled by default but can be controlled via the \IsActive\ flag.
Extensions/Revo.Extensions.History/Configuration, Extensions/Revo.Extensions.Notifications/Configuration · high confidence
FakeClock now uses AsyncLocal for thread-safe time manipulation
The FakeClock implementation in Revo.Testing.Core has been updated to use AsyncLocal storage instead of ThreadLocal. This change ensures that time value modifications are atomic and correctly scoped to asynchronous execution contexts, preventing race conditions or incorrect time values when tests run concurrently or within async workflows.
Revo.Testing/Core · high confidence
FakeRepository now respects IsDeleted flag and exposes batch-loading methods
The FakeRepository in the testing infrastructure has been updated to correctly handle soft-deleted entities: when SaveChanges is called, aggregates marked with IsDeleted are now properly transitioned to a Removed state rather than being committed. Additionally, the repository now implements FindManyAsync and GetManyAsync for optimized batch loading of aggregates by ID, and FindAllAsync returns an array instead of an IList, aligning the test double more closely with production repository behaviors.
Revo.Testing/Infrastructure/Repositories · high confidence
In-memory repository now returns arrays for bulk queries
The in-memory data access layer has been updated to return arrays (T\[\]) instead of IList\<T\> for bulk retrieval operations. Specifically, FindAllAsync and FindManyAsync now return arrays, which provides a fixed-size, read-only view of the results and may affect code expecting mutable list interfaces. This change is part of a broader refactoring to optimize batch-loading of event-sourced aggregates and align the in-memory implementation with the updated repository interfaces.
Revo.DataAccess/InMemory · high confidence
Introduced generic EF Core-based async event queue infrastructure
The async event dispatching system now uses a new generic implementation backed by Entity Framework Core, replacing previous provider-specific logic. This change introduces new database entities (AsyncEventQueue, QueuedAsyncEvent, EventSourceState, ExternalEventRecord) and a dedicated manager (AsyncEventQueueManager) to handle event queuing, checkpointing, and dispatching. For users, this provides a unified, optimized mechanism for processing async events, ensuring coordinated unit-of-work transactions and preventing duplicate enqueuing during commit.
Revo.Infrastructure/Events/Async/Generic · high confidence
Introduction of domain class ID system and aggregate root event publishing
The domain entity model now includes a new \DomainClassIdAttribute\ and \EntityTypeManager\ to assign and resolve unique identifiers and codes to domain classes, enabling type discovery and management. Additionally, the \AggregateRoot\ base class has been updated to use a \Publish\ method for dispatching events internally, replacing the previous naming convention, and enforces that events cannot be published on deleted aggregates.
Revo.Domain/Entities · high confidence
New RavenDB CRUD repository with optimized batch loading
The RavenDB provider now includes a new \RavenCrudRepository\ and its factory, introducing \GetManyAsync\ and \FindManyAsync\ methods for efficient batch retrieval of aggregates by ID. Additionally, \FindAllAsync\ has been updated to return a \T\[\]\ array instead of an \IList\<T\>\, which may affect code expecting a list interface.
Providers/RavenDB/Revo.RavenDB/DataAccess · high confidence
New async event processing pipeline with configurable startup behavior
The async event processing infrastructure has been restructured to introduce a new \AsyncEventExecutionCatchUp\ component that handles event source catch-ups and queue backlog processing during application startup. A key behavioral change is that these catch-up operations no longer block application startup by default; this is controlled by the new \WaitForEventCatchUpsUponStartup\ configuration option in \IAsyncEventPipelineConfiguration\, which defaults to false. The pipeline now includes dedicated components for dispatching events to queues (\AsyncEventQueueDispatcher\), processing them with retry logic (\AsyncEventProcessor\, \ProcessAsyncEventsJobHandler\), and managing concurrency via a locking mechanism (\LockingAsyncEventWorker\) to prevent optimistic concurrency exceptions. Additionally, new binding extensions (\AsyncEventListenerBindingExtensions\) simplify the registration of async event listeners and their associated sequencers.
Revo.Infrastructure/Events/Async · high confidence
New database initializer discovery and dependency sorting
The application now automatically discovers and executes database initializers at startup, ensuring they run in the correct order based on dependencies declared via the new InitializeAfterAttribute. This change introduces a coordinated Unit of Work for each initializer, wrapping the initialization logic in a transaction that is committed after the initializer completes, which guarantees data consistency during setup.
Revo.Infrastructure/DataAccess · high confidence
New event routing infrastructure and metadata extensions
The Revo.Domain/Events module introduces a new event routing system, including the AggregateEventRouter for managing uncommitted and replayed domain events, and the ConventionEventApplyRegistrator to automatically register event handlers based on naming conventions. Additionally, MetadataExtensions now provide nullable accessors for event metadata fields such as AggregateId, PublishDate, and StoreDate, ensuring safer handling of optional metadata values.
Revo.Domain/Events · high confidence
New mail notification channel with configurable SMTP sender
The mail notification channel has been restructured to support configurable SMTP sending. A new \SmtpMailNotificationSender\ implementation uses \System.Net.Mail.SmtpClient\ to deliver messages, replacing the previous logging-based approach. Notifications are now formatted via \IMailNotificationFormatter\ and queued as background jobs (\SendMailNotificationJob\) for asynchronous delivery. Configuration is handled through \ConfigureMailNotifications\, allowing users to provide a factory for the sender and customize the \MailNotificationsConfigurationSection\.
Extensions/Revo.Extensions.Notifications/Channels/Mail · high confidence
New programmatic configuration API for RavenDB integration
The RavenDB provider now exposes a fluent configuration API via \RavenConfigurationExtensions\, allowing users to enable RavenDB as the primary repository and activate event projections using code rather than XML. The \UseRavenProjections\ method enables automatic projector discovery by default, simplifying setup for users who rely on event sourcing projections.
Providers/RavenDB/Revo.RavenDB/Configuration · high confidence
New programmatic configuration API for core and kernel setup
The framework introduces a new programmatic configuration API (RevoConfiguration) that replaces previous setup methods, requiring developers to configure framework and module parameters via code before bootstrapping. This change adds a CoreConfigurationSection to manage core settings, including a new option to disable the security module (UseNullSecurityModule) and configure command execution, alongside a KernelConfigurationSection that allows overriding Ninject module loading and defining custom kernel actions.
Revo.Core/Configuration · high confidence
Notification buffers now use string identifiers instead of GUIDs
The notification buffering system has been refactored to allow buffers, pipelines, and governors to be identified by arbitrary string names rather than GUIDs. This change, visible in the new \NotificationBuffer\ model which now stores \Name\, \PipelineName\, and \GovernorName\ as strings, provides greater flexibility in configuring notification routing and processing.
Extensions/Revo.Extensions.Notifications/Model · high confidence
Notification buffers, pipelines, and governors now use string names instead of GUIDs
The SQL schema for the notifications extension has been updated to replace GUID-based identifiers with arbitrary string names for notification buffers, pipelines, and governors. This change introduces a new \rno\_nbf\_name\ column and renames the pipeline and governor ID columns to \rno\_nbf\_pipeline\_name\ and \rno\_nbf\_governor\_name\ respectively, providing more flexible identification. Migration scripts are provided for PostgreSQL to transform existing data, while new baseline schemas for MSSQL, PostgreSQL, and SQLite reflect this new structure.
Extensions/Revo.Extensions.Notifications/Sql · high confidence
Overhauled command bus with middleware pipeline and automatic handler discovery
The command execution model has been refactored to support a flexible middleware pipeline, allowing for pre/post filters and exception handling around command processing. A new Command Gateway routes commands to specific buses (local or remote) via a configurable router, and command handlers are now automatically discovered and registered by default, eliminating the need for manual Ninject bindings in most cases. Additionally, execution options now allow commands to run under a specific tenant context, and the Unit of Work is automatically managed and committed for commands by default.
Revo.Core/Commands · high confidence
RavenDB provider now uses Ninject DI with task-scoped sessions
The Revo.RavenDB provider has been restructured to use a new RavenModule for dependency injection, replacing previous registration methods. This change introduces task-scoped lifetimes for IAsyncDocumentSession and repository bindings, ensuring sessions are properly disposed at the end of a task context. The module also configures the RavenDB DocumentStore with optimistic concurrency and identity property conventions, and conditionally binds primary repository interfaces (ICrudRepository, IReadRepository) when useAsPrimaryRepository is enabled.
Providers/RavenDB/Revo.RavenDB · high confidence
Refactored EF Core event store with generic implementation and coordinated transactions
The EF Core event store implementation has been refactored into a new generic structure (under \Revo.Infrastructure.EventStores.Generic\), introducing dedicated classes for event stream management (\EventStream\, \EventStreamRow\), message adaptation (\EventStoreEventMessage\, \EventStoreRecordAdapter\), and catch-up mechanisms (\EventSourceCatchUp\, \ExternalEventSourceCatchUp\). This change coordinates Unit of Work transactions for EF Core, ensuring that synchronous projections, event publishing from projections, and asynchronous event dispatching are handled within a single transactional context to prevent duplicate enqueuing. It also adds support for batch-loading events via \BatchFindEventsAsync\ and \BatchFindStreamMetadataAsync\, and improves async event worker concurrency by limiting it to one active worker per queue per application instance.
Revo.Infrastructure/EventStores · high confidence
Refactored event projection infrastructure with automatic discovery and tenant-aware execution
The projection subsystem has been restructured to support automatic projector discovery and registration, coordinated Unit of Work transactions, and correct tenant context handling for async projections. New base classes (CrudEntityEventToPocoProjector, EntityEventToPocoProjector) and interfaces (IEntityEventProjector, IProjectionSubSystem) provide a convention-based framework for applying events to read models, including automatic handling of read model versioning and idempotency. The ProjectionEventListener now groups events by tenant and executes projections within a dedicated transaction scope, ensuring that event publishing from projections is transactionally safe.
Revo.Infrastructure/Projections · high confidence
Refactored read model base classes and interfaces
The Revo.Domain/ReadModel package has been restructured with new base classes and interfaces for read models. EntityReadModel now implements IManuallyRowVersioned and includes a Version property for concurrency control, while EventEntityReadModel adds an EventNumber property to track the last projected event. New interfaces like IClassEntityReadModel and ITenantReadModel provide specific capabilities for class-based and tenant-scoped read models, and the ReadModelForEntityAttribute allows explicit mapping between read models and their source entities.
Revo.Domain/ReadModel · high confidence
Refactored transaction and unit-of-work abstractions
The Revo.Core.Transactions namespace has been restructured with new interfaces (ITransaction, ITransactionCoordinator, IUnitOfWork) and implementations (CoordinatedTransaction, UnitOfWork) that introduce a coordinated commit model. This change allows repositories to operate without an active UnitOfWork and ensures that EF Core operations, sync projections, and async event dispatching are handled within a single coordinated transaction scope, improving consistency for event publishing and data persistence.
Revo.Core/Transactions · high confidence
Saga infrastructure restructured with new event dispatching and configuration APIs
The saga subsystem has been refactored to introduce a new, convention-based configuration model and a coordinated event dispatching pipeline. Users can now define saga event handling rules using the new fluent \SagaTypeConfiguration\ API (e.g., \StartsWith\, \HandlesByKey\, \HandlesAll\), which is automatically loaded via the \ConventionSagaConfigurator\ at application startup. The runtime behavior has changed to use a dedicated \SagaEventListener\ that buffers domain events and dispatches them to sagas within a single Unit of Work, ensuring that saga state changes and associated commands are committed atomically. This includes new interfaces for saga location (\ISagaLocator\), metadata storage (\ISagaMetadataRepository\), and registry management (\ISagaRegistry\), all wired together in the \SagasModule\.
Revo.Infrastructure/Sagas · high confidence
Saga key management now supports multiple associations per event handler
The saga infrastructure in Revo.Domain/Sagas has been updated to allow a single event handler to be associated with multiple saga keys. This is implemented via the new SagaEventAttribute (supporting IsAlwaysStarting and IsStartingIfSagaNotFound flags) and a convention-based scanning system that maps events to saga instances. Both BasicSaga and EventSourcedSaga now expose a Keys dictionary and methods like AddSagaKey, SetSagaKey, and RemoveSagaKey, enabling sagas to track multiple key-value pairs. For event-sourced sagas, these key changes are persisted as SagaKeysChangedEvent instances, ensuring state consistency across different persistence backends.
Revo.Domain/Sagas · high confidence
Simplified security model with new authorization interfaces and null module support
The security subsystem has been refactored to simplify user and permission management. The framework now uses \IUserContext\ for accessing the current user and their permissions, replacing the previous \ISignInManager\. A new \IUserPermissionAuthorizer\ service provides fine-grained authorization checks, backed by a \PermissionAuthorizationMatcher\ that evaluates permissions against available sets. \Permission\ and \PermissionType\ are now proper value objects, with \Permission\ accepting generic objects for \ResourceId\ and \ContextId\ to improve flexibility. Additionally, a \NullCoreSecurityModule\ can be enabled via \SecurityConfiguration.UseNullSecurityModule\ to disable security checks entirely for development or testing purposes.
Revo.Core/Security · high confidence
Unified repository with multi-store aggregate management
The repository layer has been refactored to use a unified \IRepository\ that delegates to specific \IAggregateStore\ implementations (such as \CrudAggregateStore\ for database-backed entities and \EventSourcedAggregateStore\ for event-sourced aggregates). This change introduces \FindManyAsync\ and \GetManyAsync\ for optimized batch loading, enforces that \FindAllAsync\ returns arrays, and ensures deleted aggregates are automatically removed from the store and throw \EntityDeletedException\ when accessed. The \Repository\ now coordinates a single transaction per save operation, preventing mixed-store modifications, and supports instantiation without an active \UnitOfWork\.
Revo.Infrastructure/Repositories · high confidence
Test coverage
Added tests for AggregateRoot event publishing and deletion logic; Added tests for InMemoryCrudRepository behavior; Added tests for Lambda command bus extensions and handler; Added tests for MultiValueDictionary and GenericLoggerFactory; Added tests for async event queue management and message factory; Added tests for command security authorizer and permission cache; Added tests for database initializer dependency sorting and loading; Added tests for event stream upgrade infrastructure; Added tests for in-memory job scheduler and job runner; Added tests for lifecycle configuration and notification components; Added tests for projection infrastructure components; Added tests for saga event handling and convention scanning; Added tests for security authorization components; Added tests for type versioning and indexing logic; Added unit tests for EF6 data access components; Added unit tests for SagaMetadataRepository; Added unit tests for UnitOfWorkFactory and UnitOfWork; Added unit tests for ValueObject equality, hashing, and JSON serialization; Added unit tests for core event handling components; Added unit tests for database migration infrastructure; Added unit tests for event infrastructure components; Added unit tests for event routing and convention-based registration; Added unit tests for generic event store and external event source catch-up; Added unit tests for history extension change tracking; Added unit tests for repository and aggregate store infrastructure; Added unit tests for saga infrastructure components; Added unit tests for tenancy infrastructure components; Added unit tests for the EasyNetQ provider integration; Added unit tests for the Notifications extension; Added unit tests for the TodoList domain entity; Added unit tests for the async event processing infrastructure; Added unit tests for the command bus pipeline and middleware infrastructure; Added unit tests for the new Revo configuration and kernel bootstrapping system; Disables parallel execution of xUnit tests; Disables parallel test execution in infrastructure tests.
Dependencies
Upgrade to .NET 10.0 and update core dependencies
The framework and its example applications have been upgraded to target .NET 10.0. This change updates core dependencies to match the new runtime, including Entity Framework Core 10.0, AutoMapper 14.0, Hangfire 1.8.22, and EasyNetQ 7.8.0. Additionally, the Revo.Tools.DatabaseMigrator global tool now targets .NET 10.0 and uses updated database drivers (Npgsql 10.0.0, Microsoft.Data.Sqlite 10.0.0).
(dependencies) · high confidence
Housekeeping
Initial release of Revo Framework version 1.38.4
This commit introduces the initial structure for the Revo Framework, establishing the solution layout with core, domain, and provider projects (EF6, EF Core, Hangfire, etc.), along with extensions for notifications, history, and AutoMapper. It sets the package version to 1.38.4 and configures the build system using Cake, Azure Pipelines, and SourceLink for embedded PDBs. The release notes document the immediate fix for RequestDbContextCache thread-safety in version 1.38.4, while also recording the history of prior versions including upgrades to .NET 10.0 and EF Core 10.0 in 1.38.0.
(repo-wide) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 48 → 48 (+0.0)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 44 → 44 (+0.1)
- Architecture 78 → 64 (-14.2)
- Maturity 50 → 51 (+0.3)
- Readiness 44 → 46 (+2.7)
- Security 67 → 65 (-1.5)
- Domain Modelling 58 (new)
- Event Sourcing 82 → 76 (-5.9)
- Performance 60 → 60 (+0.0)
Resolved (41)
- Cross-context type EntityState (Revo → Providers) (Providers/EF6/Revo.EF6/DataAccess/Entities/EF6CrudRepository.cs)
- Cross-context type EntityState (Revo → Providers) (Providers/EF6/Revo.EF6/DataAccess/Entities/EF6CrudRepository.cs)
- Cross-context type EntityState (Revo → Providers) (Providers/EF6/Revo.EF6/DataAccess/Entities/EF6CrudRepository.cs)
- Cross-context type EntityState (Revo → Providers) (Providers/EFCore/Revo.EFCore/DataAccess/Entities/EFCoreCrudRepository.cs)
- Cross-context type EntityState (Revo → Providers) (Providers/EFCore/Revo.EFCore/DataAccess/Entities/EFCoreCrudRepository.cs)
- Cross-context type EntityState (Revo → Providers) (Providers/EFCore/Revo.EFCore/DataAccess/Entities/EFCoreCrudRepository.cs)
- Cross-context type EntityState (Revo → Providers) (Providers/RavenDB/Revo.RavenDB/DataAccess/RavenCrudRepository.cs)
- Cross-context type EntityState (Revo → Providers) (Providers/RavenDB/Revo.RavenDB/DataAccess/RavenCrudRepository.cs)
- Cross-context type EntityState (Revo → Providers) (Providers/RavenDB/Revo.RavenDB/DataAccess/RavenCrudRepository.cs)
- Cross-context type IAggregateStore (Revo → Providers) (Providers/EFCore/Revo.EFCore/Repositories/EFCoreCrudAggregateStoreFactory.cs)
- Cross-context type IAggregateStore (Revo → Providers) (Providers/EFCore/Revo.EFCore/Repositories/EFCoreEventSourcedAggregateStoreFactory.cs)
- Low coverage: Revo.Core/Configuration/ConfigurationException.cs (Revo.Core/Configuration/ConfigurationException.cs)
- Low coverage: Revo.Core/Security/AuthorizationException.cs (Revo.Core/Security/AuthorizationException.cs)
- Low coverage: Revo.DataAccess/Entities/OptimisticConcurrencyException.cs (Revo.DataAccess/Entities/OptimisticConcurrencyException.cs)
- Low coverage: Revo.DataAccess/Entities/TablePrefixAttribute.cs (Revo.DataAccess/Entities/TablePrefixAttribute.cs)
- Low coverage: Revo.Domain/Core/DomainException.cs (Revo.Domain/Core/DomainException.cs)
- Low coverage: Revo.Domain/Entities/Basic/BasicEntity.cs (Revo.Domain/Entities/Basic/BasicEntity.cs)
- Low coverage: Revo.Domain/Sagas/SagaConfigurationException.cs (Revo.Domain/Sagas/SagaConfigurationException.cs)
- Low coverage: Revo.Infrastructure/DataAccess/Migrations/DatabaseMigrationException.cs (Revo.Infrastructure/DataAccess/Migrations/DatabaseMigrationException.cs)
- Low coverage: Revo.Infrastructure/EventSourcing/EntityDeletedException.cs (Revo.Infrastructure/EventSourcing/EntityDeletedException.cs)
- …and 21 more
New (9)
- Projects may be oversized for their cohesion (Revo.Core/Revo.Core.csproj)
- Projects may be oversized for their cohesion (Revo.Infrastructure/Revo.Infrastructure.csproj)
- Revo: 3 contract type(s) expose producer-owned ids/enums
- Split Revo.Infrastructure (Revo.Infrastructure/Revo.Infrastructure.csproj)
- doc comments repeat the names (Providers/EF6/Revo.EF6/DataAccess/Model/EntityTypeDiscovery.cs)
- doc comments repeat the names (Providers/EFCore/Revo.EFCore/DataAccess/Model/EntityTypeDiscovery.cs)
- doc comments repeat the names (Revo.Core/Commands/CommandHandlerBindingExtensions.cs)
- doc comments repeat the names (Revo.Infrastructure/EventSourcing/EntityDeletedException.cs)
- redundant comment (Revo.Infrastructure/DataAccess/Migrations/DatabaseMigrationSelector.cs)
Changes since last survey
- 5 commits — 3 feature/other, 2 fixes
By area
- (root) — 2 commits
- Revo.Infrastructure/DataAccess — 1 commit
- Revo.Infrastructure/Events — 1 commit
- Tests/Revo.Infrastructure.Tests — 1 commit
Notable commits
- fix: Fix README Todo example
- fix: Fix async event retry backoff delay
- change: Assert multiplied async retry scheduler delays
- change: Release Revo 1.38.5
- change: Validate database migration version inputs (#82)
API surface
- Unchanged — 5 HTTP endpoints
Architecture
- Unchanged — 2 containers · 5 contexts · 9 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
revoframework/Revo 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.
About this page
- The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit b93f40e799148584490bba10dad2d8acecd83fc3 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.