rabbal/DNTFrameworkCore

DNTFrameworkCore is a .NET 6 application infrastructure library that provides a modular foundation for building domain-driven applications. It supports multiple persistence backends, including Entity Framework Core and NHibernate, while offering built-in CQRS implementation via MediatR, multi-tenancy, and automated entity tracking. The system also includes specialized modules for license management with hardware fingerprinting and JWT-based authentication scaffolding for web APIs.

36 changes.

The project underwent a major upgrade to .NET 6, accompanied by a significant restructuring of the solution architecture into dedicated modules for EF Core, CQRS, and licensing. Legacy implementations, including Dapper and older Entity Framework components, were removed and replaced with modern, generic patterns using MediatR and FluentValidation. This period focused on establishing a clean, modular foundation with enhanced multi-tenancy and standardized domain models.

10 changes.

This period focused on expanding data persistence support by introducing Entity Framework Core and NHibernate integration layers, including transactional filters and CRUD services. The team also enhanced the ASP.NET Core API template with built-in JWT authentication, user management, and comprehensive test scaffolding to streamline project initialization.

The ASP.NET Core API template now ships with a complete test suite structure, including integration tests for the Role and User services and unit tests for their validators. The template provides helper classes to configure in-memory or SQLite databases for testing, along with stubs for the event bus and user session to simplify test isolation.

templates · high confidence

The CQRS infrastructure now includes new pipeline behaviors that automatically intercept commands before they are handled. LoggingBehavior records command names and payloads, ValidationBehavior integrates FluentValidation to reject invalid requests with detailed error logs, and PerformanceBehavior measures and logs execution time. A stubbed RetryBehavior is also present but currently throws NotImplementedException, indicating it is not yet functional.

src/DNTFrameworkCore.Cqrs/Behaviors · high confidence

The NHibernate integration layer now includes concrete abstract service classes (EntityService) that handle standard CRUD operations (Create, Read, Update, Delete) for entities using NHibernate's ISession. These services provide LINQ-based querying capabilities and integrate with the existing event bus, allowing developers to build domain services that persist data via NHibernate without writing boilerplate data-access code.

src/DNTFrameworkCore.NHibernate/Application · high confidence

This change introduces the foundational components of the DNTFrameworkCore library, establishing the core architecture for building .NET applications. It adds the base \ApplicationService\ and generic \EntityServiceBase\ classes to standardize CRUD operations and model mapping, alongside domain primitives like \ValueObject\, \ITrackable\, and \IRepository\. The update also integrates CQRS support via MediatR with \LoggingBehavior\ and \PerformanceBehavior\, implements a SQL Server-specific numbering hook for auto-incrementing identifiers, and provides dependency injection extensions for security, caching, and background tasks.

src/DNTFrameworkCore · high confidence

The licensing module now includes a new \FingerPrint\ class that generates a unique 16-byte hardware identifier by querying CPU, BIOS, motherboard, disk, video, and MAC address details via WMI. This identifier is used to bind licenses to specific machines. The \License\ class has been implemented with full XML serialization support, allowing licenses to be persisted and validated via XML. Additionally, \RsaExtensions\ and \XmlExtensions\ provide utilities for signing and verifying these XML documents using RSA keys, ensuring license integrity. The \LicenseExtensions\ class offers helper methods to check feature availability and retrieve attribute values from the license.

src/DNTFrameworkCore.Licensing · high confidence

The framework now provides a centralized exception handling middleware that maps specific error types (such as validation, domain, and database exceptions) to standardized JSON problem details, improving API error responses. Additionally, it introduces a new tenancy infrastructure featuring a \TenantPipelineMiddleware\ that allows forking the HTTP request pipeline to apply tenant-specific configurations, alongside dependency injection support for tenant sessions.

src/DNTFrameworkCore.Web · high confidence

The framework introduces new interfaces for the Command side of CQRS, specifically \ICommand\ and \ICommandHandler\. Commands now inherit from MediatR's \IRequest\ and are strongly typed to return a \Result\ object (from \DNTFrameworkCore.Functional\), replacing the previous validation helper logic. This change establishes a standardized contract for command handlers to return success or failure states via the \Result\ type, aligning with Domain-Driven Design principles.

src/DNTFrameworkCore.Cqrs/Commands · high confidence

The licensing module now includes foundational domain classes to manage license validity and features. ExpirationTime provides a value object for tracking license expiration dates, including support for infinite validity. LicenseFeature defines the structure for individual license capabilities with names, display names, and values. SigningKey introduces cryptographic key management, allowing the generation of RSA public and private keys for license signing.

DNTFrameworkCore.Licensing · high confidence

This update introduces several new capabilities within the EF Core integration layer. It adds an abstract EntityService base class to simplify standard CRUD operations for entities. It also provides a new JSON value converter and comparer, allowing complex objects to be stored as JSON blobs in the database with proper change tracking. Additionally, an EF Core-based configuration provider and source are added, enabling application settings to be loaded from and persisted to a database via a KeyValueService. Finally, the DbContextCore is enhanced with a hook system that automatically manages creation/modification tracking, tenancy, row-level security, and row integrity checks.

src/DNTFrameworkCore.EFCore · high confidence

This release introduces two new capabilities within the DNTFrameworkCore.Web.EFCore package. First, it adds a new Cryptography module that allows ASP.NET Core Data Protection keys to be persisted directly to a database via Entity Framework Core, configurable through the new \PersistKeysToDbContext\<TContext\>\ extension method. Second, it adds a \TransactionFilter\ that automatically manages database transactions for MVC action methods, committing on success and rolling back on failure or unhandled exceptions.

src/DNTFrameworkCore.Web.EFCore · high confidence

The aspnet-core-api template now ships with a complete authentication and authorization implementation. It introduces a new \AuthController\ for login/logout, backed by \AuthenticationService\ and \TokenService\ which handle JWT generation, validation, and token revocation. The template also includes a \DbSetup\ class to seed an initial administrator user and roles, and provides \UsersController\ and \RolesController\ scaffolds with permission-based access control. Additionally, a \NotificationHub\ for SignalR is included to support real-time notifications.

templates/aspnet-core-api/content · high confidence

The DNTFrameworkCore.Dapper project has been removed, deleting the IDapperRepository interface and its DapperRepository implementation. This eliminates the Dapper-based data access layer from the framework, meaning applications can no longer use this specific repository pattern for database operations.

src/DNTFrameworkCore.Dapper · high confidence

The Entity Framework integration layer for the application service and auditing subsystems has been removed. This deletes the \CrudService\ abstract classes and their dependency configuration (\CrudServiceDependency\), eliminating the built-in generic CRUD operations for aggregates. Additionally, the \AuditLog\ entity and \AuditLogStore\ implementation are removed, meaning the framework no longer provides automatic persistence of service execution audit trails via Entity Framework.

src/DNTFrameworkCore.EntityFramework/Application · high confidence

The Entity Framework Core implementation of the data access layer has been removed from the framework. This change deletes the \DbContextCore\ abstract class, the \IUnitOfWork\ interface, and the associated dependency injection setup (\DbContextCoreDependency\). It also removes the entire \Context/Extensions\ namespace, eliminating helper methods for query filtering, sorting, paging, entity validation, and tenant-aware filtering, as well as the \HookEngine\ used for pre- and post-save entity hooks. Additionally, the EF Core-specific transaction wrappers and providers have been deleted, indicating a shift away from Entity Framework Core in this module.

src/DNTFrameworkCore.EntityFramework/Context · high confidence

The Entity Framework integration layer has been stripped of its core persistence infrastructure. The \ServiceCollectionExtensions\ file, which previously registered auditing, settings, data protection, and unit-of-work services, has been deleted, meaning these features are no longer available via this assembly. Additionally, the \HookEntityMetadata\ class (used for tracking entity state changes) and the \DataProtectionKeyRepository\ (used for storing encryption keys in the database) have been removed.

src/DNTFrameworkCore.EntityFramework · high confidence

The multi-tenancy support in this module has been removed, specifically deleting the middleware and extensions that integrated the StructureMap dependency injection container. This includes the removal of \MultiTenantContainerMiddleware\ and \StructureMapTenantContainerBuilder\, which previously handled per-tenant container resolution and service provider replacement, as well as the \StructureMapApplicationBuilderExtensions\ and \MultiTenancyContainerExtensions\ used to wire these components. The \MemoryCacheTenantResolver\ implementation has also been deleted, meaning the framework no longer provides built-in caching for tenant resolution within this package.

src/DNTFrameworkCore.Web.MultiTenancy · high confidence

The legacy DbLogger class, which previously handled logging to a database context, has been removed from the codebase. This change eliminates the direct dependency on the specific DbLogger implementation within the Entity Framework logging module, likely as part of a broader refactoring to replace it with new providers like FileLoggerProvider and DbLoggerProvider mentioned in the commit history.

src/DNTFrameworkCore.EntityFramework/Logging · high confidence

The Entity Framework-specific implementation for application settings has been removed. This includes the \SettingStore\ (which handled CRUD operations for settings in the database), the \SettingConfiguration\ (which defined the database table schema and indexes for the \Setting\ entity), and the \SettingExtensions\ (which provided conversion methods between domain and persistence models). Users relying on this specific EF Core integration for storing and retrieving settings will no longer have access to these components.

src/DNTFrameworkCore.EntityFramework/Configuration · high confidence

The NHibernate integration now includes a new \QueryableExtensions\ class that enables users to apply filtering, sorting, and paging directly to LINQ queries. This change introduces support for \CancellationToken\ in asynchronous operations and implements an inline filtering mechanism, allowing for more efficient and flexible data retrieval when using NHibernate as the persistence layer.

src/DNTFrameworkCore.NHibernate/Linq · high confidence

The transaction interception logic in the NHibernate integration has been refactored to manage database transactions via the NHibernate ISession instead of the previous generic ITransactionProvider abstraction. This change simplifies the interceptor by injecting the session directly, ensuring that transaction boundaries (begin, commit, rollback) are handled through NHibernate's native session API rather than an external provider.

src/DNTFrameworkCore.NHibernate/Transaction · high confidence

The query infrastructure in the CQRS module has been refactored to align with MediatR's generic patterns. Non-generic interfaces like IQuery and IPagedQuery have been replaced with generic versions (IQuery\<TResult\>, IPagedQuery\<TReadModel\>) that inherit from IRequest\<TResult\> and specific request interfaces (IPagedRequest, IFilteredPagedRequest). Consequently, concrete query classes such as PagedQuery and FilteredPagedQuery are now generic and inherit from corresponding request base classes, removing hardcoded properties like Page, PageSize, and Filter in favor of the structured request model approach.

src/DNTFrameworkCore.Cqrs/Queries · high confidence

The FluentValidation integration in DNTFrameworkCore has been refactored to improve validation accuracy and align with FluentValidation best practices. The previous extension method \AddFluentModelValidation\ on \IDNTBuilder\ has been replaced by \WithFluentValidation\ on \FrameworkBuilder\, which now registers a custom \ServiceProviderValidatorFactory\ to resolve validators via the service provider. Additionally, the \FluentValidationModelValidator\ now uses \IValidatorFactory.GetValidator\<T\>()\ instead of type-based lookup, and returns \ValidationFailure\ objects directly instead of wrapping them in \ModelValidationResult\, ensuring that validation errors are reported with correct property names and messages.

src/DNTFrameworkCore.FluentValidation · high confidence

The core domain model has been restructured to support richer domain scenarios and improved tracking. A new generic Entity base class now handles identity, equality, and domain event management, replacing previous implementations. New interfaces and classes for tracking (TrackableEntity) and configuration (KeyValue) have been added. Several existing classes, including Cache, ProtectionKey, Log, and NumberedEntity, have been moved from provider-specific namespaces (e.g., DNTFrameworkCore.EntityFramework) to the core DNTFrameworkCore namespace and updated to inherit from the new Entity base. The Log entity has been expanded with additional user and tenant context properties, and the NumberedEntity's property has been renamed from NextNumber to NextValue.

DNTFrameworkCore · high confidence

The tenancy handling in the web layer has been restructured to support isolated service lifetimes per tenant. A new \TenantContainerMiddleware\ now creates a child service container for each identified tenant, ensuring that tenant-specific dependencies are resolved separately from the root application scope. The \TenantPipelineMiddleware\ has been simplified to use a direct dictionary for tenant-specific request pipelines, removing the previous \TenantPipelineBuilderContext\ abstraction. Additionally, \TenantResolutionMiddleware\ now explicitly resolves the tenant using a dedicated \ITenantResolutionStrategy\ and \ITenantStore\ rather than relying on generic context items, and \TenantSession\ has been refactored to derive tenant identity from either the authenticated user's claims or the resolved tenant context.

src/DNTFrameworkCore.Web.Tenancy/Internal · high confidence

The \NumberingPreInsertHook\ class, which previously automatically generated and assigned sequential numbers to entities implementing \INumberedEntity\ during database inserts, has been removed. This eliminates the automatic numbering behavior for these entities.

src/DNTFrameworkCore.EntityFramework.SqlServer · high confidence

The internal hooks in \src/DNTFrameworkCore.EntityFramework/Context/Internal\ that automatically managed entity lifecycle behaviors have been removed. This eliminates the automatic application of Yekke corrections, row-level security user ID assignment, concurrency row version tracking, soft-delete flagging, multi-tenant ID injection, and creation/deletion audit tracking (timestamps, user IDs, IPs, and browser names) for entities implementing the corresponding interfaces.

src/DNTFrameworkCore.EntityFramework/Context/Internal · high confidence

The automatic numbering system for SQL Server has been refactored to support resetting generated numbers based on the values of other fields in the entity. This change introduces a new \PreInsertNumberedEntityHook\ that generates unique numbers by creating composite keys from specified fields, ensuring uniqueness across those dimensions. The underlying infrastructure has also been migrated from the legacy \IUnitOfWork\ abstraction to \IDbContext\, and the \NumberedEntity\ configuration now uses the correct \HasDatabaseName\ method for index naming.

src/DNTFrameworkCore.EFCore.SqlServer/Numbering · high confidence

The framework has been upgraded to target .NET 6, enforced by a new global.json SDK pin (6.0.100) and common.props settings. The solution structure has been significantly refactored: the legacy DNTFrameworkCore.EntityFramework and DNTFrameworkCore.Dapper projects have been replaced by DNTFrameworkCore.EFCore and DNTFrameworkCore.FluentValidation, while multi-tenancy and web extensions have been split into dedicated modules (DNTFrameworkCore.Web.Tenancy, DNTFrameworkCore.Web.EFCore). New projects for CQRS integration (DNTFrameworkCore.Cqrs.EFCore, DNTFrameworkCore.Cqrs.Web), licensing (DNTFrameworkCore.Licensing), and NHibernate support (DNTFrameworkCore.NHibernate) have been added, alongside a comprehensive set of corresponding test projects.

(repo-wide) · high confidence

Added CQRS test API project scaffolding; Added domain model and CQRS scaffolding for the test API; Added test application handlers and policy for CQRS validation; Added test application scaffolding for identity and catalog domains; Added test infrastructure for identity seeding, token management, and database migrations; Added test infrastructure scaffolding for CQRS API; Added tests for Extensibility Toolkit extension fields and properties; Added unit tests for TransactionInterceptor behavior; Added unit tests for querying components; Added unit tests for the EF Core Numbering mechanism; Added unit tests for the licensing module; Removal of auditing unit tests; Removed Entity Framework hook and numbering test suites; Removed transaction interceptor tests; Updated eventing tests to reflect DomainEvent to BusinessEvent rename; Updated validation tests to align with new service configuration and result APIs.

The framework and its templates have been upgraded from .NET Core 2.2 to .NET 6, targeting the \net6.0\ framework across all libraries and test projects. This migration includes updating core dependencies such as \Microsoft.EntityFrameworkCore\ to version 6.0.0, \FluentValidation\ to 10.3.5, and \MediatR\ to 9.0.0. The project structure has been refactored to use the SDK-style format, replacing explicit package references for ASP.NET Core components with the \Microsoft.AspNetCore.App\ framework reference. Additionally, the \DNTFrameworkCore.EntityFramework\ and \DNTFrameworkCore.Dapper\ projects have been removed or replaced by new modular libraries like \DNTFrameworkCore.EFCore\, \DNTFrameworkCore.Cqrs\, and \DNTFrameworkCore.NHibernate\, and the \aspnet-core-api\ template has been updated to reflect these new dependencies and the .NET 6 target.

(dependencies) · high confidence

A new solution file (nupkg.sln) has been added to the nupkg directory, defining the build structure for the DNTFrameworkCore suite. It includes projects for the core library, Entity Framework Core integration, SQL Server provider, FluentValidation, Licensing, and Web components (including EF Core and Tenancy support), organized under a src folder with standard Debug/Release configurations for Any CPU, x64, and x86 platforms.

nupkg · high confidence

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

• CAI 49 → 45 (-3.3)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 54 → 53 (-0.9)
• Architecture 90 → 89 (-0.3)
• Maturity 51 → 51 (+0.0)
• Readiness 41 → 36 (-5.1)
• Security 69 → 47 (-21.9)
• Domain Modelling 49 → 60 (+10.8)
• Event-Driven 100 → 100 (+0.0)

• Bounded contexts not declared
• Build did not complete in the analyzer
• CommentedOutCode (src/DNTFrameworkCore.EFCore.SqlServer/NumberingService.cs)
• CommentedOutCode (src/DNTFrameworkCore.EFCore.SqlServer/NumberingService.cs)
• CommentedOutCode (src/DNTFrameworkCore.EFCore.SqlServer/NumberingService.cs)
• CommentedOutCode (src/DNTFrameworkCore.EFCore.SqlServer/NumberingService.cs)
• CommentedOutCode (src/DNTFrameworkCore.EFCore.SqlServer/NumberingService.cs)
• CommentedOutCode (test/DNTFrameworkCore.TestCqrsAPI/Application/Catalog/Handlers/ProductCommandHandlers.cs)
• CommentedOutCode (test/DNTFrameworkCore.TestCqrsAPI/Application/Catalog/Handlers/ProductCommandHandlers.cs)
• CommentedOutCode (test/DNTFrameworkCore.TestCqrsAPI/Application/Catalog/Handlers/ProductCommandHandlers.cs)
• CommentedOutCode (test/DNTFrameworkCore.TestCqrsAPI/Domain/SeedWork/Identity.cs)
• CommentedOutCode (test/DNTFrameworkCore.TestCqrsAPI/Domain/SeedWork/Identity.cs)
• CommentedOutCode (test/DNTFrameworkCore.TestCqrsAPI/Domain/SeedWork/Identity.cs)
• CommentedOutCode (test/DNTFrameworkCore.TestCqrsAPI/Domain/SeedWork/Identity.cs)
• Dead code: SplitCsv (src/DNTFrameworkCore/Extensions/StringExtensions.cs)
• Dead code: TenantContainerMiddleware (src/DNTFrameworkCore.Web.Tenancy/Internal/TenantContainerMiddleware.cs)
• Duplicated block (21 lines × 2) (src/DNTFrameworkCore.Web/Security/AllowUploadSafeFilesAttribute.cs)
• Duplicated block (9–10 lines × 2) (src/DNTFrameworkCore/Cryptography/CryptographyExtensions.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 20 more

• CommentedOutCode (src/DNTFrameworkCore.Cqrs.EFCore/Behaviors/TransactionBehavior.cs)
• CommentedOutCode (src/DNTFrameworkCore.Web.Tenancy/DependencyInjection.cs)
• CommentedOutCode (test/DNTFrameworkCore.TestWebApp/Application/Identity/Validators/UserValidator.cs)
• Documentation: no architecture or design documentation (docs/index.md)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (10–11 lines × 2) (src/DNTFrameworkCore/Cryptography/CryptographyExtensions.cs)
• Duplicated block (11 lines × 2) (src/DNTFrameworkCore.Web/API/EntityController.cs)
• Duplicated block (11 lines × 2) (src/DNTFrameworkCore.Web/API/EntityController.cs)
• Duplicated block (11 lines × 3) (src/DNTFrameworkCore/Mapping/MapperExtensions.cs)
• Duplicated block (11 lines × 6) (src/DNTFrameworkCore/Mapping/MapperExtensions.cs)
• Duplicated block (12 lines × 2) (src/DNTFrameworkCore/Validation/Interception/DataAnnotationMethodParameterValidator.cs)
• Duplicated block (18 lines × 2) (src/DNTFrameworkCore/Mapping/MapperExtensions.cs)
• Duplicated block (18 lines × 2) (src/DNTFrameworkCore/Mapping/MapperExtensions.cs)
• Duplicated block (21 lines × 2) (src/DNTFrameworkCore/Mapping/MapperExtensions.cs)
• Duplicated block (22 lines × 2) (src/DNTFrameworkCore/Mapping/MapperExtensions.cs)
• Duplicated block (23 lines × 2) (src/DNTFrameworkCore.Web/Security/AllowUploadSafeFilesAttribute.cs)
• Duplicated block (31 lines × 2) (src/DNTFrameworkCore.EFCore/Querying/QueryableExtensions.cs)
• Duplicated block (5 lines × 2) (src/DNTFrameworkCore.Web/API/EntityController.cs)
• Duplicated block (5 lines × 2) (src/DNTFrameworkCore.Web/Authentication/DistributedCacheTicketStore.cs)
• Duplicated block (8 lines × 2) (src/DNTFrameworkCore.Web/Http/HttpRequestExtensions.cs)
• …and 44 more

• Unchanged — 10 HTTP endpoints

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

• DNTFrameworkCore.Licensing

• DNTFrameworkCore.Licensing → DNTFrameworkCore

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

rabbal/DNTFrameworkCore 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.