reinforced/Reinforced.Tecture

Reinforced.Tecture is a .NET architecture framework that structures applications using a command and query pattern, providing a unified interface for data access and business logic. It supports Entity Framework Core and raw SQL execution, offering features like deep cloning, transaction management, and comprehensive tracing for debugging. The system also includes a testing library that generates assertions and test data to validate command and query behaviors.

38 changes.

This period marks the initial release and structural establishment of the Reinforced.Tecture framework, introducing its core architecture for managing commands, queries, and aspects. The work focuses on implementing the foundational infrastructure, including channel multiplexing, service management, and tracing systems. Additionally, it establishes the Entity Framework Core runtime support and provides a complete sample application with corresponding test coverage.

5 changes.

This period focused on introducing new capabilities for time queries and query hashing, alongside a significant expansion of the test suite. The work added core infrastructure for accessing system time and computing query hashes, while simultaneously increasing test coverage for Tecture's core components and sample applications.

A new sample application, Reinforced.Samples.ToyFactory, has been added to the Playground. This includes the core application files (Program.cs, Startup.cs) to configure the ASP.NET Core host and dependency injection, a DTO for creating toy types, and configuration files for development and production environments.

Playground/Reinforced.Samples.ToyFactory · high confidence

Introduces a new time query aspect that allows applications to retrieve the current date and time. The update adds a \Query\ aspect class and corresponding wrapper classes (\DateTimeWrapper\ and \DateTimeOffsetWrapper\) that expose \Now\, \UtcNow\, and \Today\ properties. These are accessible via extension methods on the \Read\<QueryChannel\<Query\>\>\ type, enabling consistent, traceable access to system time within the query pipeline.

Aspects/Reinforced.Tecture.Aspects.Time · high confidence

Introduced a new EF Core implementation for the Direct SQL and ORM aspects, enabling direct SQL command and query execution via \ExecuteSqlRaw\ and \FromSqlRaw\. The change adds \DirectSqlRunner\ and \EFCore\_DirectSql\_CommandAspect\/\QueryAspect\ classes to handle side effects and queries, along with supporting infrastructure like \EfCoreMapper\ for table/column mapping and \InterpolatorFactory\ for SQL interpolation. Extension methods are provided on \ChannelBinding\ to register these aspects, allowing users to configure EF Core-based direct SQL and ORM capabilities within the Tecture framework.

Runtimes/Reinforced.Tecture.Runtimes.EFCore/Aspects/DirectSql · high confidence

Users can now utilize Entity Framework Core for transactional operations within the application. This change introduces the EfCoreTransaction and EfCoreTransactionManager classes, which wrap the underlying IDbContextTransaction and DbContext to manage database transactions. This enables developers to leverage EF Core's transactional capabilities for their data access layer.

Runtimes/Reinforced.Tecture.Runtimes.EFCore/Transactions · medium confidence

A new NomenclatureController was added to handle toy type management, exposing endpoints to create, list, and retrieve toy types via HTTP. The controller integrates with the ORM aspect for database operations and includes trace logging. Additionally, a CommonQueries helper class was introduced to provide a reusable method for fetching entities by ID.

Playground/Reinforced.Samples.ToyFactory/Controllers · high confidence

Introduced new types in the Tracing/Commands/Cycles namespace to support loop-based tracing. This includes the Cycle, Iteration, and EndCycle command classes, along with the CycleTraceContext and its interface ICycleTraceContext. These components enable the system to track the start, individual iterations, and end of logical cycles within the command pipeline, providing visibility into loop structures during execution.

Reinforced.Tecture/Tracing/Commands/Cycles · high confidence

Introduced new entity classes (Blueprint, BlueprintResources, ToyType) and a DTO (ResourceWithQuantity) to represent the structure of toy blueprints and their associated resources. Added corresponding services (Blueprints, Nomenclature) that enable creating, updating, and deleting blueprints and toy types, as well as associating resources with blueprints via the BlueprintResources join table. This adds the ability to define and manage the composition of toys through their blueprints.

Playground/Domains/Reinforced.Samples.ToyFactory.Logic · high confidence

Introduced a new query hashing mechanism to support ORM aspect fixes. This includes a new \Hashbox\ utility class for computing SHA-256 hashes of query data and an \IHashable\ interface for entities to expose their sensitive data for hashing.

Reinforced.Tecture/Queries · medium confidence

New synthetic command types—Comment, End, and Save—have been added to the tracing subsystem. These non-executable commands serve as markers in the trace, allowing users to insert explanatory comments, mark the end of a command queue, or denote specific save points within the execution flow.

Reinforced.Tecture/Tracing/Commands · high confidence

Introduces the EfCoreAsyncExecutor class, which implements IAsyncQueryExecutor to provide asynchronous query execution for Entity Framework Core. The accompanying EfCore\_Orm\_QueryAspect class registers this executor and provides the necessary infrastructure for handling async queries and retrieving entity keys.

Runtimes/Reinforced.Tecture.Runtimes.EFCore/Aspects/Orm/Query · high confidence

The library introduces a new channel configuration system in the \Reinforced.Tecture.Entry\ namespace. Users can now configure channels using \WithChannel\ on the \TectureBuilder\, which accepts a \ChannelBinding\ to set up query and command channels. The \Extensions\ class provides fluent methods like \ForQuery\ and \ForCommand\ (with overloads for up to 8 command types) to register aspects and savers for specific channels. Additionally, the \Tecture\ class now exposes \BeginTrace\ and \EndTrace\ methods for collecting trace data, and the \TectureBuilder\ exposes \WithTestData\ for test data sources. This change shifts the API towards a more explicit channel-based configuration model.

Reinforced.Tecture/Entry · high confidence

The DirectSql aspect now supports raw SQL execution via a 'SQL stroke' API. Users can construct SQL commands using expression-based strokes for both commands (via \Extensions.Sql\ over \CommandChannel\) and queries (via \Extensions.SqlQuery\ over \QueryChannel\). The change includes the \Sql\ command class, a \RawQuery\ result wrapper with \As\<T\>()\ and \AsAsync\<T\>()\ methods, and infrastructure for parsing and interpolating SQL templates. This enables developers to write and execute raw SQL statements directly through the framework's channel and aspect system.

Aspects/Reinforced.Tecture.Aspects.DirectSql · high confidence

The ToyFactory sample application now includes a complete Entity Framework Core database setup, including the \ToyFactoryDbContext\ configured for a MySQL/MariaDB backend, along with initial migration files that define the schema for entities such as Blueprints, Resources, and Supply chains. This establishes the data access layer for the sample, allowing the application to manage its database state and perform operations like deep cloning query results or deleting by primary key as indicated by the commit messages.

Playground/Reinforced.Samples.ToyFactory.Data · medium confidence

The repository now includes the core build configuration (Directory.Build.props) and solution file (Reinforced.Tecture.sln) for the Reinforced.Tecture architecture framework. This change establishes the project structure, enabling the building and packaging of the library and its associated aspects (Orm, DirectSql, Time, Cache) and runtimes (EFCore). The update also adds the project's SVG icon and a comprehensive README that explains the framework's benefits for various roles, provides usage examples, and links to documentation.

(repo-wide) · high confidence

Added a new deep cloning system within the \Reinforced.Tecture.Cloning\ namespace, enabling the creation of deep copies of objects and their nested structures. This includes the \DeepCloner\ static class with \DeepClone\ methods, a \DeepCloneOperator\ to manage the cloning process, and a \CloningDelegateEmitter\ to generate the necessary delegates for various types. This feature allows users to perform deep clones of complex object graphs, including collections and anonymous types, ensuring that all nested objects are also cloned rather than just the top-level reference.

Reinforced.Tecture/Cloning · high confidence

Added new domain entities for the warehouse subsystem, including Resource, MeasurementUnit, ResourceSupply, ResourceSupplyItem, and their status history. Implemented corresponding services (Manage and Supply) that allow users to create, rename, and delete measurement units, as well as create, update, and remove resource supplies, including handling item additions and stock quantity updates via direct SQL commands.

Playground/Domains/Reinforced.Samples.ToyFactory.Logic.Warehouse · medium confidence

The EF Core runtime now includes new command runners for Add, Delete, DeletePk, Derelate, Relate, Update, and UpdatePk operations. These runners handle entity state changes (Added, Modified, Deleted) and persist them via SaveChanges, while skipping persistence when test data is provided. The aspect also registers these runners and manages context disposal.

Runtimes/Reinforced.Tecture.Runtimes.EFCore/Aspects/Orm/Command · high confidence

Adds the core command execution and transaction handling components to the library. This includes the \CommandBase\ abstract class and \CommandExtensions\ for command metadata and debugging, the \CommandRunner\ and \CommandRunner\<T\>\ abstract classes for executing commands, and the \CommandsDispatcher\ to orchestrate command execution and save operations. Additionally, it introduces the \TransactionManager\ and \ChannelTransactionsManager\ to manage database transactions for each channel, supporting both synchronous and asynchronous execution flows.

Reinforced.Tecture/Commands · high confidence

The update adds a new service management infrastructure to the library. A \ServiceManager\ is introduced to handle the lifecycle of services, including initialization, disposal, and invoking \OnSave\/\OnFinally\ hooks across all registered services. Additionally, an \ActionsQueue\ is added to manage the execution of deferred actions (both synchronous and asynchronous) that are queued after \SaveChanges\ calls. The \TectureServiceBase\ is expanded to expose \Finally\ and \Then\ methods, allowing developers to register callbacks that execute after the save or post-save phases, respectively.

Reinforced.Tecture/Services · high confidence

The ORM aspect now includes new command types for managing entity lifecycles and relationships. Users can add entities via the \Add\ command, which supports fluent extension methods for up to eight entity types. Deletion is handled by the \Delete\ command, which allows removing entities by instance or by primary key (using the new \DeletePk\ command). Additionally, the \Derelate\ command enables breaking one-to-many relations, while the \Relate\ command (partially shown) supports establishing them. These changes expand the ORM aspect's capabilities for data manipulation and relationship management.

Aspects/Reinforced.Tecture.Aspects.Orm · high confidence

The library introduces new channel abstractions and extension methods that allow users to retrieve query and command aspects directly from channel read/write ends. The \Extensions.cs\ file adds \Aspect\<T\>\ and \PleaseAspect\<T\>\ extension methods for \Read\ and \Write\ interfaces, enabling access to \QueryAspect\ and \CommandAspect\ instances. Additionally, \Interfaces.cs\ defines the core channel interfaces (\CanQuery\, \CanCommand\, \QueryChannel\, \CommandChannel\), while \ReadWrite.cs\ implements the internal \SRead\ and \SWrite\ structs that handle aspect multiplexing. A T4 template (\Generated.tt\) is also added to generate multi-tooling channel variants.

Reinforced.Tecture/Channels · high confidence

The library introduces a new set of interfaces and implementations in the \Reinforced.Tecture.Tracing.Promises\ namespace to support a promise-based tracing model. This includes the \Promised\<T\>\ marker interface, the \PromisedQuery\<T\>\ struct for recording query metrics, and specific promise types like \Demanding\<T\>\ for successful results, \Catching\<T\>\ for errors, and \Containing\<T\>\ for pre-populated test data. These changes enable the framework to defer and trace query execution details more effectively, allowing for better testing and observability of query outcomes.

Reinforced.Tecture/Tracing/Promises · medium confidence

The Reinforced.Tecture.Testing namespace now includes new classes to support testing workflows. A NoValidateAttribute allows users to explicitly skip validation for specific properties, while a ValidatedAttribute enables declarative validation of command properties with optional opt-out flags. Additionally, a TestData interface and exception class provide a mechanism for supplying and retrieving test data for queries, and a TestingContext class offers auxiliary tooling for processing commands and queries, including trace collection and transaction management.

Reinforced.Tecture/Testing · high confidence

The library introduces a new tracing system for tracking queries and command execution. This includes a new \QueryRecord\ class to capture query results, hashes, and timing, a \Trace\ class to represent the story of applied side effects, and a \TraceCollector\ to gather these events. Users can now access recorded queries via the \Trace.Queries\ property, filter traces by channel using \Trace.OfChannel\<T\>()\, and validate or explain traces using the new \TraceValidator\ and \TraceExplainer\ components.

Reinforced.Tecture/Tracing · high confidence

The library now includes new internal classes—ChannelConfigurator, ChannelMultiplexer, and TestDataProvider—within the Channels/Multiplexer namespace. These classes implement a multiplexer pattern that manages known channels and registers query and command aspects, allowing the framework to route and execute commands and queries through specific channel types. This change introduces a new internal architecture for handling channel-specific aspect registration and command execution.

Reinforced.Tecture/Channels/Multiplexer · high confidence

The Reinforced.Tecture library introduces a new internal architecture for managing command and query aspects, including a base \AspectBase\ class and generated \CommandAspect\ implementations for up to 64 commands. A new \ServiceReflector\ class enables dynamic service instantiation via private constructors, and extension methods on \ITecture\ provide convenient access to services and data sources. Additionally, custom exception types \TectureException\ and \TectureValidationException\ are added to handle internal errors and validation failures.

Reinforced.Tecture · high confidence

The ToyFactory logic layer now provides new extension methods for querying entities by their primary key. The \Db\ interface is introduced to define command/query channels for ORM and DirectSql operations, alongside a base \IEntity\ interface. Additionally, the \Queries\ class adds helper methods such as \EnsureExists\, \ById\, and \ByIdRequired\ to simplify fetching entities and projections by ID, with the latter two throwing exceptions if the entity is not found.

Playground/Domains/Reinforced.Samples.ToyFactory.Logic.Channels · medium confidence

Added C\# code-based test data generation; Added Root helper class for test project; Added code formatting logic for test data generation; Added code generation and formatting utilities for testing; Added logic tests for blueprint and nomenclature operations; Added test data record implementations for anonymous types and collections; Added test data syntax generation infrastructure; Added test infrastructure for MariaDB SQL interpolation and case management; Added tests for the Create Blueprint workflow; Added tests for the CreateAndRenameBlueprintWorks logic; Added tests for warehouse operations; Added unit tests for core Tecture features; Added unit tests for the CreateTypeWorks logic; Added validation and assertion utilities for testing; Added validation test generation infrastructure.

The project has been updated to use .NET 5.0 and Entity Framework Core 5.0.13. This upgrade ensures compatibility with the latest .NET runtime and provides the corresponding EF Core features and improvements.

(dependencies) · high confidence

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

• CAI 38 → 39 (+0.4)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 75 → 73 (-1.6)
• Architecture 96 → 96 (+0.0)
• Maturity 44 → 44 (+0.0)
• Readiness 48 → 45 (-3.4)
• Security 22 → 24 (+2.0)
• Performance 60 → 60 (+0.0)

• Bounded contexts not declared
• Coverage not measured — analyzer environment
• Duplicated block (8 lines × 2) (Runtimes/Reinforced.Tecture.Runtimes.EFCore/Aspects/DirectSql/Command/EFCore_DirectSql_CommandAspect.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• IL efficiency: 4 authored method(s) exceed the IL budget (Playground/Domains/Reinforced.Samples.ToyFactory.Logic.Warehouse/Services/Supply.cs)
• LLM evaluation failed
• No exposed public API
• Split Reinforced.Tecture.Aspects.Orm
• Test runner surfaced no tests
• dormant codebase — no living knowledge left to concentrate

• CommentedOutCode (Playground/Reinforced.Samples.ToyFactory.Tests/WarehouseTests/ManageTests.cs)
• CommentedOutCode (Testing/Reinforced.Tecture.Testing/Data/CSharpCodeTestDataGenerator.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 3) (Aspects/Reinforced.Tecture.Aspects.Orm/Commands/DeletePk/DeletePk.cs)
• Duplicated block (10 lines × 3) (Aspects/Reinforced.Tecture.Aspects.Orm/Queries/AsyncExtensions.cs)
• Duplicated block (10 lines × 8) (Aspects/Reinforced.Tecture.Aspects.DirectSql/Commands/Sql.cs)
• Duplicated block (11 lines × 2) (Runtimes/Reinforced.Tecture.Runtimes.EFCore/Aspects/Orm/Command/DeletePkCommandRunner.cs)
• Duplicated block (14 lines × 3) (Aspects/Reinforced.Tecture.Aspects.Orm/Queries/AsyncExtensions.cs)
• Duplicated block (14 lines × 3) (Aspects/Reinforced.Tecture.Aspects.Orm/Queries/AsyncExtensions.cs)
• Duplicated block (16 lines × 2) (Reinforced.Tecture/Tracing/Promises/PromiseExtensions.cs)
• Duplicated block (17 lines × 2) (Reinforced.Tecture/Commands/CommandsDispatcher.cs)
• Duplicated block (21–22 lines × 3) (Aspects/Reinforced.Tecture.Aspects.Orm/Queries/AsyncExtensions.cs)
• Duplicated block (22 lines × 2) (Reinforced.Tecture/Commands/CommandsDispatcher.cs)
• Duplicated block (22–23 lines × 2) (Aspects/Reinforced.Tecture.Aspects.Orm/Queries/AsyncExtensions.cs)
• Duplicated block (6 lines × 2) (Aspects/Reinforced.Tecture.Aspects.Orm/Queries/Traced/Enumerators/Generic/WrappedEnumerator.cs)
• Duplicated block (9 lines × 2) (Aspects/Reinforced.Tecture.Aspects.Orm/Queries/Traced/Queryables/TraceWrapping/TracedQueryable.cs)
• Duplicated block (9 lines × 2) (Runtimes/Reinforced.Tecture.Runtimes.EFCore/Aspects/DirectSql/Command/EFCore_DirectSql_CommandAspect.cs)
• End-of-life runtime: .NET net5.0
• End-of-life runtime: .NET netcoreapp3.1
• …and 27 more

• Unchanged — 2 HTTP endpoints

• Unchanged — 2 containers · 0 contexts · 0 edges

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

reinforced/Reinforced.Tecture 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.