dr-marek-jaskula/DomainDrivenDesignUniversity

Shopway is a .NET 8 e-commerce backend application built on a clean architecture with a CQRS-based application layer. It manages products, orders, and user accounts, supporting features like fuzzy search, batch processing, and two-factor authentication. The system utilizes a SQL database with an outbox pattern for reliable event handling and provides both minimal and FastEndpoints API surfaces for client interaction.

114 changes.

The codebase was restructured into a strict Clean Architecture with distinct layers for Domain, Application, Infrastructure, and Presentation, each supported by comprehensive documentation and unit tests. The implementation introduced CQRS with MediatR, Ulid-based identifiers, and robust pagination and batch processing capabilities. This period focused on establishing the foundational domain models, persistence patterns, and API endpoints required for the Shopway application.

20 changes.

This period focused on implementing a generic proxy framework to enable dynamic filtering, sorting, and mapping for entities like OrderHeader and Product. It also introduced a new user and role-based authorization model and integrated a dummy payment gateway service.

The presentation layer now supports API key-based authentication. A new \AllowAnonymousHandler\ allows unauthenticated access where needed, while a \RequiredApiKeyAttribute\ and its corresponding \ApiKeyRequirementHandler\ enforce validation of the \X-Api-Key\ header against configured values. The \ApiKeyService\ retrieves and compares keys from the configuration, enabling developers to protect specific endpoints by applying the attribute with a required key enum.

src/Shopway.Presentation/Authentication/ApiKeyAuthentication · high confidence

The repository now includes a complete Docker Compose setup to run the application and its dependencies locally. This includes containers for the SQL database, Redis, Papercut, the main application, a dummy payment gateway, and an OpenTelemetry stack (Jaeger, Prometheus, Grafana, and Aspire Dashboard). Developers can now start the entire environment with a single command, facilitating easier local testing and integration.

(repo-wide) · high confidence

New domain enums LogicalOperation (And, Or) and SortDirection (Ascending, Descending) have been introduced to the common enums namespace. These provide structured types for logical operations and sorting preferences, with SortDirection configured for JSON serialization.

src/Shopway.Domain/Common/Enums · high confidence

The OpenApi area now includes a new dark theme for the Swagger UI, applied via the new \SwaggerDark.css\ file. Additionally, the codebase introduces several C\# classes to configure and customize the OpenAPI/Swagger generation: \OpenApiOptionsSetup\ handles API versioning and metadata; \OpenApiDefaultValues\ implements an operation filter to populate default values and required flags on parameters; \OpenApiUtilities\ provides extension methods to add JWT and API Key security schemes and custom headers; and \ProblemDetailsExample\ supplies example data for error responses.

src/Shopway.Presentation/OpenApi · medium confidence

Users can now submit a request to remove a specific review from a product. This change introduces the command, handler, validator, and response structures required to process the removal of a review associated with a product.

src/Shopway.Application/Features/Products/Commands/RemoveReview · high confidence

New caching decorators (CachedOrderHeaderRepository, CachedProductRepository) were added to the persistence layer. These implement the repository interfaces and wrap the underlying database calls with a 30-second in-memory cache using the FusionCache library. This change introduces a behavioral change where read operations for order headers and products may return cached data, reducing database load and improving response times for these specific entities.

src/Shopway.Persistence/Repositories/Decorators · high confidence

The application now supports removing products. A new command, handler, validator, and response have been added to the product feature, allowing users to delete a product by its ID.

src/Shopway.Application/Features/Products/Commands/RemoveProduct · high confidence

Users can now update a product's price and modify a product's review (stars and description) through new CQRS command handlers and validators. The UpdateProduct command allows changing the price of an existing product, while the UpdateReview command enables partial updates to a review's star rating and description text.

src/Shopway.Application/Features/Products/Commands/UpdateProduct, src/Shopway.Application/Features/Products/Commands/UpdateReview · high confidence

A new set of static utility classes has been added to the domain layer, including ArrayUtilities, CallerArgumentUtilities, CollectionUtilities, DictionaryUtilities, DisposableUtilities, EnumUtilities, ExpressionUtilities, HashUtilities, IEnumerableUtilities, ListUtilities, NumberUtilities, ObjectUtilities, QueryableUtilities, RandomUtilities, RangeUtilities, ReflectionUtilities, RegexUtilities, StringUtilities, StructUtilities, TaskUtilities, and Utf8JsonReaderUtilities. These provide helper methods for array and collection operations, expression tree manipulation, filtering, hashing, and JSON parsing.

src/Shopway.Domain/Common/Utilities · high confidence

Users can now sort order headers dynamically by status and total discount. This change introduces the OrderHeaderDynamicSortBy type and associated constants to define allowed sort properties, enabling flexible ordering of order header lists in the application layer.

src/Shopway.Application/Features/Orders/Queries/OrderHeaderOffsetPageDynamicWithMappingQuery, src/Shopway.Domain/Orders/DataProcessing/Sorting · high confidence

The application layer now includes two new middleware components. The ErrorHandlingMiddleware catches unhandled exceptions and returns standardized JSON error responses with appropriate HTTP status codes (404, 400, 403, or 500) while logging unexpected errors. The RequestTimeMiddleware monitors request duration and logs a warning if a request takes longer than 4 seconds, providing visibility into slow endpoints.

src/Shopway.Application/Middlewares · high confidence

The application now supports fuzzy search and word segmentation, allowing users to find approximate matches for misspelled or incomplete queries. The \SymSpellFuzzySearch\ implementation provides methods to find the best single suggestion, retrieve multiple top suggestions, and segment concatenated text into meaningful words using a built-in English frequency dictionary.

src/Shopway.Infrastructure/FuzzySearch · high confidence

Introduces a comprehensive set of commands for managing orders, including creating headers, adding, updating, and removing order lines, as well as batch upserting lines. It also adds handlers for payment process states (start, finalize, cancel, refund) and status changes. Additionally, it includes queries for retrieving order headers, lines, and payment details, along with a domain event handler for order creation.

src/Shopway.Application/Features/Orders/Commands · high confidence

New query handlers and request/response types have been added to the product feature, enabling users to retrieve products by ID, key, or name (including fuzzy search), and to perform dynamic, cursor-based, or offset-based paginated queries with custom filters, sorting, and mapping strategies. A new ProductResponse and ReviewResponse are introduced to support these operations.

src/Shopway.Application/Features/Products/Queries · high confidence

Users can now submit reviews for products via the new AddReview command, which validates and processes review submissions including title, description, and star rating. Additionally, the system introduces a BatchUpsertProduct command that allows for the bulk creation or update of products, handling both insert and update operations in a single batch request, with validation for product keys, prices, and unit of measure codes.

src/Shopway.Application/Features/Products/Commands/BatchUpsertProduct · high confidence

A new query and its handler have been added to the application layer to fetch order headers. The GetOrderHeaderByIdQuery accepts an OrderHeaderId and returns an OrderHeaderResponse, while the corresponding handler uses the IOrderHeaderRepository to retrieve the data and map it to the response.

src/Shopway.Application/Features/Orders/Queries/GetOrderHeaderById · high confidence

New pipeline behaviors have been introduced in the persistence layer to manage database transactions and validate entity references. CommandTransactionPipeline and CommandWithResponseTransactionPipeline wrap CQRS commands in database transactions using the configured execution strategy. QueryTransactionPipeline applies similar transactional handling to queries. Additionally, ReferenceValidationPipeline validates that referenced entities exist in the database (checking both cache and database), returning validation errors if references are invalid.

src/Shopway.Persistence/Pipelines · high confidence

New query handlers and response models are introduced for retrieving user details by username, listing a user's roles, fetching role permissions, and retrieving detailed permission information. These additions expand the application's ability to query user and authorization data through the CQRS pattern.

src/Shopway.Application/Features/Users/Queries · high confidence

The Shopway.Persistence.Framework layer now includes a DbContextFactory for design-time tooling, a base ShopwayDbContext that applies entity configurations from the assembly, and a generic UnitOfWork\<TContext\> that centralizes transaction management, audit field updates, and cache invalidation logic.

src/Shopway.Persistence/Framework · high confidence

New persistence converters have been added for domain value objects including Amount, Description, Discount, Email, ExternalIdentityProvider, FirstName, LastName, PasswordHash, PhoneNumber, Price, ProductName, RefreshToken, Revision, Stars, Title, TwoFactorTokenHash, TwoFactorToptSecret, UomCode, and Username. Each converter handles the mapping between the domain value object and its database representation (e.g., int, string, decimal), ensuring consistent storage and comparison of these types within the Shopway persistence layer.

src/Shopway.Persistence/Converters/ValueObjects · high confidence

The Shopway application now includes two new background jobs managed by the Quartz scheduler. The ProcessOutboxMessagesJob polls for and publishes outbox messages every 10 seconds, while the DeleteOutdatedSoftDeletableEntitiesJob runs monthly to permanently remove soft-deleted entities older than one year.

src/Shopway.Persistence/BackgroundJobs · high confidence

A new IdempotentDomainEventHandlerDecorator has been introduced in the infrastructure layer to ensure domain events are processed only once. This decorator wraps existing domain event handlers and leverages the IOutboxRepository to track processed consumers, preventing duplicate handling of domain events. The implementation includes logging for event handling activities.

src/Shopway.Infrastructure/Decorators · high confidence

A new UserIdConverter and UserIdComparer have been added to the persistence layer to handle the conversion and comparison of UserId entities. The converter maps UserId instances to and from strings using a ULID format, while the comparer ensures correct equality checks for these entities within the database context.

src/Shopway.Persistence/Converters/EntityIds · medium confidence

A new query, OrderHeaderWithMappingQuery, has been introduced to fetch an order header by its ID, supporting an optional dynamic mapping configuration. This enables the application layer to retrieve order data with flexible mapping strategies, as handled by the corresponding query processor that delegates to the order header repository.

src/Shopway.Application/Features/Orders/Queries/OrderHeaderWithMappingQuery · high confidence

The application now supports a generic proxy framework that allows dynamic querying and paginated listing of any entity type. This includes generic handlers for fetching single entities by ID or by a unique key, as well as generic handlers for paginated lists using either cursor-based or offset-based pagination. Each generic query type (by ID, by key, and page queries) includes its own validator to ensure required fields like filters, sorting, and mapping are correctly structured. The \MediatorProxyService\ has been extended with strategy attributes to route requests for specific entities (such as \OrderHeader\, \Product\, and \User\) to these new generic handlers, enabling consistent data access patterns across the system.

src/Shopway.Application/Features/Proxy · high confidence

Added a new dummy payment gateway implementation within the Shopway infrastructure layer. This includes configuration options for public/secret keys and webhooks, along with services for managing checkout sessions, processing payment status webhooks, and handling refunds. The implementation provides a fully functional, albeit dummy, payment processing flow that can be swapped for a real provider later.

src/Shopway.Infrastructure/Payments · high confidence

Added a new set of interfaces and base classes in the CQRS Batch namespace to support batch command processing. This includes IBatchCommand and IBatchCommandHandler for handling batch requests and responses, along with a builder pattern (IBatchResponseBuilder, IBatchResponseEntryBuilder) to validate and construct batch responses. The IBatchRequest interface was also added to define the contract for batch requests.

src/Shopway.Application/Abstractions/CQRS/Batch · high confidence

A new static helper class, CommonSpecification, has been added to the persistence layer to streamline the creation of query specifications. This utility provides multiple overloads that accept filters, sorting, mapping, and inclusion builders, automatically applying tags for identification. This change simplifies how queries are constructed by centralizing the setup of filters, mappings, and includes into a single, reusable entry point.

src/Shopway.Persistence/Specifications/Common · high confidence

The Orders domain now includes new domain models: OrderHeader, OrderLine, and Payment, along with their associated repositories, constants, and error definitions. OrderHeader manages order status transitions (e.g., New → InProgress → Shipped → Delivered) and enforces that order lines can only be added when the order is in 'New' status. Payment handling is integrated via an IPaymentGatewayService interface, allowing the system to process, refund, and track payment statuses. The OrderLine model tracks individual items within an order, including product summary, amount, and line-level discounts. These changes establish the core structure for managing orders, their line items, and associated payments within the domain layer.

src/Shopway.Domain/Orders · high confidence

The PaymentGateway service is introduced, providing a new endpoint for managing payment integrations. It includes a dummy gateway implementation with typed event models (CheckoutSessionCompleted, CheckoutSessionAsyncPaymentSucceeded/Failed) and a WebhookService that publishes payment results to subscribed issuers. The service exposes HTTP endpoints for sharing secrets, configuring webhooks, redirecting to payment sessions, and publishing payment results. Secret management is handled via a file-based store, and the service is configured with Swagger for API exploration.

PaymentGateway · high confidence

The Products area now includes the core domain entities: Product, Review, and their associated keys (ProductKey, ReviewKey). Each entity is paired with a custom System.Text.Json converter to handle serialization of their unique keys. Domain events (ProductCreatedDomainEvent, ReviewAddedDomainEvent, ReviewRemovedDomainEvent) are also introduced to track these changes within the domain layer.

src/Shopway.Domain/Products · high confidence

The Shopway.App project has been added to the solution, providing the application's entry point and startup configuration. This includes Program.cs for dependency registration and HTTP pipeline setup, a Dockerfile for containerization, configuration files for database, authentication, and telemetry, and an AssemblyReference class. This change establishes the foundation for running the Shopway application.

src/Shopway.App · high confidence

The domain layer now uses Ulid (Universally Unique Lexicographically Sortable Identifier) for entity identifiers, enabling cursor pagination and improved query performance. A custom source generator (Shopway.SourceGenerator) automatically generates strongly typed, readonly record struct EntityIds (e.g., ProductId) with built-in System.Text.Json converters. The domain also introduces new enumerations for user attributes, specifically Gender (Male, Female) and Rank (Standard, Premium, VIP).

src/Shopway.Domain · high confidence

Added the Application layer to the project structure, including an AssemblyReference class and a comprehensive ReadMe.md file that documents the CQRS abstraction, validation, pagination strategies (offset and cursor), manual mapping patterns, source-generated logging, and a dynamic proxy service for generic querying.

src/Shopway.Application · high confidence

Added new utility classes in the Application layer to support core application features. BatchUtilities provides helper methods to filter and inspect batch response entries (e.g., identifying inserted, updated, or error entries). CacheUtilities offers extension methods for generating cache keys and managing cache entries for entities. FluentValidationUtilities adds custom validation rules for filters, sorting, and mapping configurations, as well as custom validators for enums and value objects. PageUtilities converts query results into offset or cursor-based page responses. ProblemDetailsUtilities standardizes the creation of HTTP problem details from domain errors. ResponseUtilities simplifies wrapping responses into success results. These utilities centralize common logic, improving consistency and maintainability across the application layer.

src/Shopway.Application/Utilities · high confidence

Added new classes BatchResponseBuilder, BatchResponseBuilderFactory, and BatchResponseEntryBuilder to the Shopway infrastructure layer. These components provide a fluent, chainable API for validating and processing batch requests (such as batch upserts for products and order lines). The builder separates valid requests into insert and update categories, handles duplicate detection, and aggregates validation errors, allowing the application to process multiple items in a single batch operation while maintaining clear success and error states for each entry.

src/Shopway.Infrastructure/Builders · high confidence

Added the command, handler, validator, and response types for the CreateProduct feature. The command carries product key, price, and UoM code; the handler checks for existing products and creates them via the repository; validation uses FluentValidation to enforce value object constraints.

src/Shopway.Application/Features/Products/Commands/CreateProduct · high confidence

Added new domain components in the DataProcessing/Proxy namespace to support dynamic query operations. This includes DynamicFilter, DynamicMapping, and DynamicSortBy classes that enable flexible, runtime-defined filtering, object mapping, and sorting logic. These are paired with corresponding interfaces (IFilter, IMapping, ISortBy) and repository contracts (IProxyRepository, IProxyWithKeyRepository) that accept these dynamic processors. Additionally, an OffsetOrCursorPage helper was added to manage pagination strategy selection between offset and cursor-based paging.

src/Shopway.Domain/Common/DataProcessing/Proxy · high confidence

The application now includes four new exception classes in the domain layer: a base DomainException, EnumerationNotFoundException, InvalidLikePatternException, and ValidationException. These provide specific error handling for validation failures, missing enumerations, and invalid patterns, replacing previous generic exception handling.

src/Shopway.Domain/Common/Exceptions · high confidence

The presentation layer now exposes a comprehensive set of new API endpoints. For orders, controllers handle header creation, status changes, soft deletes, and line item management (add, update, remove, and batch upsert). Payment processing endpoints allow starting, finalizing, canceling, and refunding payments, alongside webhooks for success and cancel events. Product management includes creating, updating, and removing products, along with review management (add, update, remove) and batch upserts. User management endpoints cover registration, login, two-factor authentication (TOTP), Google authentication, and role/permission administration. Additionally, a generic proxy controller provides dynamic and generic query capabilities for various data types.

src/Shopway.Presentation/Controllers · high confidence

The persistence layer now includes a suite of new repository implementations—Authorization, OrderHeader, Outbox, Product, Proxy, ProxyWithKey, and User repositories—each providing specific data access methods for their respective domain entities. Additionally, a new caching mechanism has been added via the \PersistenceCache\ class, which pre-compiles reflection-based validation methods into a \FrozenDictionary\ for performance optimization.

src/Shopway.Persistence/Repositories · medium confidence

The Shopway.Persistence module is initialized with core infrastructure: an AssemblyReference class for scanning configurations, a connection string configuration for local and test databases, and a comprehensive README documenting the persistence architecture, including background jobs, Redis caching strategies, and domain event handling.

src/Shopway.Persistence · high confidence

Added new product filtering and sorting implementations to the domain layer. The filtering subsystem now includes static, dynamic, and fuzzy filters for products, allowing users to search by name, revision, price, and UOM code, as well as perform fuzzy matching. The sorting subsystem provides static, dynamic, and common sorting options for product name, revision, price, and UOM code, enabling users to order product lists by these attributes.

src/Shopway.Domain/Products/DataProcessing/Filtering · high confidence

Added new mapping classes for the Product domain to define how product data is transformed into DataTransferObjects. A static mapping (ProductStaticMapping) is provided with predefined fields (Id, ProductName, Revision, Price, UomCode, and Reviews) and a dynamic mapping (ProductDynamicMapping) that allows flexible property selection based on a defined set of allowed properties. These changes establish the data processing layer for product entities.

src/Shopway.Domain/Products/DataProcessing/Mapping · medium confidence

The persistence layer now provides structured specifications for querying products by their unique identifiers, keys, names, and revisions. This includes a new \ProductSpecification\ class that exposes methods to fetch a single product by ID, retrieve multiple products by a list of IDs, or filter by product name and revision. It also supports fetching product names distinctly and includes variations for loading related data such as reviews or specific review details. These changes enable more modular and reusable query logic for product data access.

src/Shopway.Persistence/Specifications/Products · high confidence

A new specification class, OrderHeaderSpecification.ById, has been added to the persistence layer. This component implements the specification pattern to define how order headers are retrieved from the database, including support for eager loading related data such as order lines and payments. This change provides a structured way to query order headers by ID, with optional filtering by user ID.

src/Shopway.Persistence/Specifications/OrderHeaders · high confidence

The domain layer now includes a new, centralized error handling system. The \Error\ class provides a standardized way to represent failures, including common scenarios like validation errors, not found, already exists, null references, and invalid arguments. These errors can be easily converted into \ValidationResult\ or \Result\ types for consistent error propagation. Additionally, \ErrorUtilities\ provides helper methods to build validation results and conditionally add errors to a list, streamlining the process of collecting and managing domain errors.

src/Shopway.Domain/Common/Errors · high confidence

The application layer now includes a comprehensive set of interfaces to support CQRS patterns, including base interfaces for queries (IQuery, IQueryHandler), commands (ICommand, ICommandHandler), and page-based queries (IPageQuery, IOffsetPageQuery, ICursorPageQuery) with their corresponding handlers. Additionally, a proxy service interface (IMediatorProxyService) is added to facilitate generic mapping and query execution, while service lifetime markers (IScoped, ITransient) are introduced to support dependency injection registration.

src/Shopway.Application/Abstractions/CQRS · high confidence

The persistence layer now includes a new \ConfigurationUtilities\ class that provides reusable methods for configuring entities as auditable or soft-deletable, along with discriminator support. Additionally, specific \IEntityTypeConfiguration\ implementations are added for \Customer\, \OrderHeader\, \OrderLine\, \OutboxMessage\, \OutboxMessageConsumer\, \Payment\, \Permission\, \Product\, \Review\, \Role\, \RolePermission\, \RoleUser\, and \User\. These configurations define the database schema mappings, including column types, constraints, relationships, and indexes. The \User\ configuration now includes fields for two-factor authentication (TOTP secret, token hash) and refresh tokens. The \OrderLine\ configuration stores the \ProductSummary\ as a JSON column. New value converters are introduced for \DateOnly\ and \Ulid\ types.

src/Shopway.Persistence/Configurations · high confidence

The application now uses a centralized \ApplicationCache\ to store reflection-based metadata about allowed filter operations, sort properties, and mapping properties. This cache is populated at startup by scanning the assembly for types implementing \IDynamicFilter\, \IDynamicSortBy\, and \IDynamicMapping\, and also caches validation result factories for response types. This change improves performance by avoiding repeated reflection calls and ensures consistent access to these metadata sets across the application.

src/Shopway.Application/Cache · high confidence

The domain layer now uses a structured Result pattern to handle success and failure states for operations. New types \Result\<T\>\ and \ValidationResult\<T\>\ provide a consistent way to return outcomes with associated values or errors, replacing previous ad-hoc error handling. The \Result\ class includes static factory methods (\Success\, \Failure\) and properties (\IsSuccess\, \IsFailure\), while \ValidationResult\ specifically handles arrays of \Error\ objects. Utility extensions are also added for converting results to tasks and safely accessing values.

src/Shopway.Domain/Common/Results · high confidence

The domain layer now includes a structured authorization model with strongly-typed permission and role enums (PermissionName, PermissionType, RoleName) and corresponding domain classes (Permission, Role, RolePermission, RoleUser). This provides a foundation for managing user permissions and role assignments within the application.

src/Shopway.Domain/Users/Authorization · high confidence

The presentation layer now includes a new abstraction for minimal APIs, featuring an \ApiController\ base class that encapsulates MediatR's \ISender\ and standard API metadata. Additionally, the codebase introduces interfaces (\IEndpoint\, \IEndpointGroup\) and a \BaseEndpointGroup\ implementation to support automatic registration of minimal API endpoints via a \RegisterEndpointGroup\ pattern, replacing or supplementing the previous controller-based routing approach.

src/Shopway.Presentation/Abstractions · high confidence

The application layer now includes new interfaces and validators to standardize data access and security. Pagination is supported via \CursorPageQueryValidator\ and \OffsetPageQueryValidator\ for validating query parameters. Security is enhanced with \ISecurityTokenService\ for JWT and refresh token management, \IToptService\ for two-factor authentication, and \IEmailSender\ for notifications. Additionally, \IValidator\ and \IFuzzySearch\ interfaces are introduced to standardize validation logic and search capabilities.

src/Shopway.Application/Abstractions · high confidence

Adds core domain building blocks to the application: an \AggregateRoot\ for managing domain events, a \DomainEvent\ record for serialization, an \Entity\ base class, an \Enumeration\ utility for typed constants, and both a record-based and an inheritance-based \ValueObject\ implementation. These changes establish the structural foundation for the domain layer, enabling consistent entity management, event tracking, and value object equality.

src/Shopway.Domain/Common/BaseTypes · high confidence

The presentation layer now enforces access control through new, generic authorization handlers (PermissionRequirementHandler and RoleRequirementHandler) that work with strongly-typed enum-based permissions and roles. These handlers utilize a new IUserAuthorizationService interface and its implementation (UserAuthorizationService) to validate user permissions and roles via an underlying repository, allowing for more type-safe and flexible authorization rules in the application.

src/Shopway.Presentation/Authentication/RolePermissionAuthentication · medium confidence

The DataProcessing folder now contains a comprehensive set of new classes that support cursor-based and offset-based pagination (CursorPage, OffsetPage), structured filtering (FilterByEntry with Predicate), sorting (SortByEntry with direction and priority), and object mapping (MappingEntry, DataTransferObject). These components provide the underlying structures and JSON converters that allow the application to handle complex data queries and transformations.

src/Shopway.Domain/Common/DataProcessing · high confidence

The application layer now includes new response types to support different pagination strategies and batch processing. Specifically, \CursorPageResponse\ and \OffsetPageResponse\ provide cursor-based and offset-based pagination respectively, each exposing metadata like current/next cursors or page counts. Additionally, \BatchEntryStatus\ and \BatchResponseEntry\ are introduced to handle batch operation results, allowing individual entries in a batch to report success, update, or error states. These changes enable more flexible data retrieval and batch processing capabilities for API consumers.

src/Shopway.Application/Features · high confidence

The domain layer now defines explicit enumerations for order and payment states, including OrderStatus (New, InProgress, Shipped, Delivered, OnHold, Rejected) and PaymentStatus (NotReceived, Confirmed, Canceled, Failed, Received), each accompanied by utility classes that enforce valid state transitions and status checks. Additionally, new domain events (NewPaymentAddedDomainEvent, OrderHeaderCreatedDomainEvent, OrderLineAddedDomainEvent) are introduced to signal key order lifecycle moments, enabling subscribers to react to these specific domain occurrences.

src/Shopway.Domain/Orders/Enumerations, src/Shopway.Domain/Orders/Events · medium confidence

The Users domain now includes the core domain models: a User entity with support for two-factor authentication (including TOTP secrets and token hashes), a Customer entity, and associated value objects and repository interfaces. Additionally, domain events for user registration and two-factor token creation are introduced to track these state changes.

src/Shopway.Domain/Users · high confidence

This change introduces a new FastEndpoints implementation and a parallel set of Minimal API endpoints for handling order headers, product reviews, and generic proxy queries. The FastEndpoints layer adds specific endpoint classes (e.g., \SoftDeleteOrderHeaderFastEndpoint\, \GetProductByIdFastEndpoint\) that wrap existing application commands and queries, utilizing the \FastEndpoints\ library for routing and configuration. Simultaneously, a new Minimal API layer is introduced in \src/Shopway.Presentation/MinimalEndpoints\, providing equivalent functionality via \IEndpoint\ implementations and \MapGroup\ registrations. Both layers implement authorization checks (e.g., \OrderHeaderCreatedByUserRequirement\, \GenericProxyPropertiesRequirement\) and versioning metadata, effectively doubling the available API surface with a generic proxy query endpoint for retrieving entities by ID, key, or page.

src/Shopway.Presentation/FastEndpoints, src/Shopway.Presentation/MinimalEndpoints · high confidence

A new query implementation for retrieving order headers using cursor-based pagination. This change introduces support for dynamic filtering, sorting, and mapping of order header data, enabling more flexible and efficient data retrieval for the orders feature.

src/Shopway.Application/Features/Orders/Queries/OrderHeaderCursorPageDynamicWithMappingQuery · high confidence

A new set of interfaces has been introduced in the data processing layer to standardize how queries are constructed and executed. This includes pagination contracts (ICursorPage, IOffsetPage, IPage), dynamic filtering (IDynamicFilter), sorting (IDynamicSortBy), and mapping (IDynamicMapping) interfaces, alongside supporting abstractions for include builders (IIncludeBuilder, IThenIncludeBuilder) and like providers (ILikeProvider). These changes provide a consistent, strongly-typed way to apply filters, sorts, and mappings to entity queries.

src/Shopway.Domain/Common/DataProcessing/Abstractions · high confidence

The application layer now includes new mapping classes for OrderHeader, OrderLine, Payment, Product, Review, User, and Permission. These static classes provide extension methods and helper functions to convert domain entities and value objects into their corresponding response DTOs. This change introduces the infrastructure for serializing order headers, lines, and payments, as well as product summaries, review details, user information, and permission data, enabling the API to return structured responses for these entities.

src/Shopway.Application/Mappings · high confidence

The domain layer now introduces four new value objects in the Orders module: Amount, Discount, ProductSummary, and Session. Each is implemented as a sealed record class with explicit validation logic and error handling, ensuring that order-related data adheres to business rules (e.g., amount ranges, discount limits, and non-empty identifiers). These objects provide a consistent, type-safe way to create and validate order data within the application.

src/Shopway.Domain/Orders/ValueObjects · high confidence

Added new utility classes in the persistence layer to handle database interactions: DbContextUtilities for managing entity attachment to the change tracker, DomainEventUtilities for serializing domain events, MigrationsUtilities for applying database migrations with retry logic, and QueryableUtilities for advanced query operations including cursor-based pagination, dynamic LINQ filtering, and SQL-like pattern matching.

src/Shopway.Persistence/Utilities · high confidence

The SourceGenerators area introduces a new base infrastructure (IncrementalGeneratorBase) and specific generators for entity IDs, entity ID comparers, entity ID converters, and enum converters. These generators produce C\# code for value objects, including strongly typed IDs with JSON serialization support, EF Core value converters, and enum string converters, each triggered by specific attributes. The change also includes unit tests for these generators and utility classes for testing.

SourceGenerators · high confidence

Added two new utility classes in the Presentation layer to support minimal APIs. EndpointConventionBuilderUtilities provides helper methods to configure API versioning and add authorization or API key summaries to endpoint builders. ResultUtilities introduces extension methods to convert domain results into appropriate HTTP responses, including mapping success states to Ok or BadRequest results, handling authorization outcomes, and generating ProblemDetails for validation and invalid request errors.

src/Shopway.Presentation/Utilities · high confidence

The persistence layer is now fully registered via a new \PersistenceLayerRegistration\ entry point that wires up background services (Quartz), database context (SQL Server), caching (FusionCache with Redis/Memory), repository implementations, MediatR pipelines, health checks (Redis, SQL, DbContext, App), and OpenTelemetry (logs, metrics, tracing). This introduces support for distributed caching, background job scheduling, structured logging, and application health monitoring.

src/Shopway.Persistence/Registration · high confidence

Users can now register, log in, and manage their accounts through a suite of new commands. This includes standard email/password login, Google authentication, and two-factor authentication (TOTP) for enhanced security. The update also introduces user management capabilities, allowing administrators to assign or remove roles and permissions, as well as create, delete, and modify permissions and their associated properties.

src/Shopway.Application/Features/Users/Commands · high confidence

Users can now only access or modify order headers they created. This is enforced by a new authorization requirement and handler that verify the current user's ID matches the creator of the order header, failing access if the user is not the creator.

src/Shopway.Presentation/Authentication/OrderHeaders · high confidence

A new empty interface IApiMarker was added to the wwwroot directory, likely serving as a marker or placeholder for the wwwroot layer.

src/Shopway.App/wwwroot · medium confidence

The application layer now includes three new pipeline behaviors that wrap request handling. The FluentValidationPipeline intercepts requests to perform validation before execution, returning a cached validation result on failure. The LoggingPipeline records the start and completion of requests, distinguishing between successful completions and failures (including validation errors and single errors) using structured logging. The QueryCachingPipeline caches successful query results using a FusionCache, with a default duration of 2 minutes, to avoid redundant processing for cached queries.

src/Shopway.Application/Pipelines · high confidence

New domain event handlers have been introduced to react to product and review creation and removal events. Specifically, the system now clears the cache when a review is removed, logs product creation details, and outputs console messages when products or reviews are created or added.

src/Shopway.Application/Features/Products/Events · high confidence

The application now validates critical configuration settings at startup, preventing the application from running with invalid or missing options. New validators have been introduced for Authentication, Cache, Database, Google Authorization, Health Check, Mail Sender, and OpenTelemetry settings. Additionally, a new \Validator\ class has been added to the infrastructure layer to support chaining validation logic and building failure results.

src/Shopway.Infrastructure/Validators · high confidence

The application layer startup is now consolidated into a single registration class that wires up the Mediator, Fluent Validation, and middleware pipeline. This includes registering the \IMediatorProxyService\ and a new \CreateOrderHeaderOpenTelemetry\ service. Additionally, the Mediator registration is expanded to automatically register generic query handlers for all entity types, supporting lookups by ID, key, and both cursor and offset-based pagination.

src/Shopway.Application/Registration · high confidence

The application now organizes all external service and feature settings into a dedicated \Options\ namespace within the infrastructure layer. This introduces strongly-typed configuration classes for Authentication (including Google OAuth and JWT bearer tokens), Cache, Database, Email (MailSender), Health Checks, and OpenTelemetry. Each setting is paired with an \OptionsSetup\ class that binds \appsettings.json\ sections to these models, ensuring consistent and type-safe access to configuration values across the system.

src/Shopway.Infrastructure/Options · high confidence

The infrastructure layer now uses a dedicated registration system to configure services, options, and dependencies. This includes registering fuzzy search, decorators, and various validators for configuration options. Additionally, a dummy payment gateway is configured for development or testing purposes.

src/Shopway.Infrastructure/Registration · medium confidence

The presentation layer's startup configuration has been consolidated into a dedicated \PresentationLayerRegistration\ class that orchestrates the setup of JSON serialization, controllers, OpenAPI/Swagger documentation, API versioning, security/authorization, and both minimal and fast endpoints. This change introduces explicit registration of Google authentication, configures CORS to allow all headers, methods, and origins, and sets up API versioning via the \Asp.Versioning\ library with header-based version detection. Additionally, the \OpenApiRegistration\ class now supports multiple API versions (1.0 and 2.0) in Swagger UI, and the \SecurityRegistration\ class registers JWT Bearer, Cookie, and Google authentication schemes along with custom authorization handlers for order headers and generic proxies.

src/Shopway.Presentation/Registration · medium confidence

The persistence layer now organizes all database-related string constants into a dedicated \Constants\ namespace. This includes explicit mappings for table names (e.g., \Address\, \Customer\, \OrderHeader\), column types, schema names, and specific product query specifications. By centralizing these values, the codebase ensures consistent naming and reduces the risk of typos or mismatched strings across the persistence implementation.

src/Shopway.Persistence/Constants · high confidence

The database schema has been updated to support new features and improve data integrity. A soft-delete pattern was added to the OrderHeader table, allowing orders to be logically removed rather than permanently deleted. Concurrency tokens were added to the UpdatedOn columns of multiple entities (User, Review, Product, Payment, OrderLine, OrderHeader, Customer) to prevent lost updates. The OutboxMessage table was introduced to support reliable message delivery via the outbox pattern. Additionally, the OrderLine table was modified to store a JSON ProductSummary instead of a direct ProductId reference, and redundant foreign key references were removed from the Payment table.

src/Shopway.Persistence/Migrations · high confidence

Added documentation for the infrastructure layer, clarifying that it provides implementations for abstractions used by the application layer. The new ReadMe file details the Idempotency pattern for domain events, the Outbox pattern for atomic transactional publishing, the FuzzySearch service, and the dummy Payment Gateway integration.

src/Shopway.Infrastructure · high confidence

The presentation layer now includes an AssemblyReference class to expose the assembly for reflection, and a comprehensive ReadMe.Presentation.md that documents the layer's structure, including controllers, exception handling, and OpenAPI configuration. The documentation details two authorization approaches (permission-based and API key), two-factor authentication flows (email and TOTP), Google OAuth integration, proxy authorization, and the use of FastEndpoints and MinimalApi for routing and performance.

src/Shopway.Presentation · high confidence

Users can now apply dynamic filters to the OrderHeader entity, including support for nested collection and reference types. The new filtering configuration allows querying on OrderHeader properties such as CreatedBy, Status, and TotalDiscount, as well as deeply nested fields like Payment status, OrderLine details, and ProductSummary information. This enables more granular data retrieval for order headers and their associated data.

src/Shopway.Domain/Orders/DataProcessing/Filtering · high confidence

The application layer now includes four new exception classes—BadRequestException, ForbidException, NotFoundException, and UnavailableException—each inheriting from the standard Exception type. These changes allow the application to handle and surface specific error conditions more precisely.

src/Shopway.Application/Exceptions · high confidence

The system now defines a strict, explicit list of allowed properties for mapping OrderHeader data. This change introduces a new constants file that enumerates the specific fields (such as Id, Status, Payments, and OrderLines) that can be mapped, alongside a dynamic mapping record that enforces these constraints during data processing.

src/Shopway.Domain/Orders/DataProcessing/Mapping · medium confidence

The persistence layer now uses a source-generator approach for converting enums to and from their string representations in the database. New files in the \Shopway.Persistence.Converters.Enums\ directory define metadata for \ExecutionStatus\, \Gender\, \OrderStatus\, \PaymentStatus\, and \PermissionType\ via the \\[GenerateEnumConverter\]\ attribute, while \RankConverter\ remains as a manual implementation. This change streamlines how enum states are mapped to the database, ensuring consistent serialization and deserialization of these values.

src/Shopway.Persistence/Converters/Enums · medium confidence

The domain layer now supports a new pattern for registering and caching strategy delegates. A new \Discriminator\ record and \StrategyAttribute\ (including a generic variant) allow methods to be annotated with attributes that map to specific discriminator keys. The \StrategyCacheFactory\ builds a frozen dictionary of these strategies, enabling efficient, attribute-driven dispatch. This replaces previous discriminator-based lookup mechanisms with a more flexible, attribute-based approach.

src/Shopway.Domain/Common/Discriminators · high confidence

New base classes are introduced in the persistence layer to standardize transactional behavior. CommandTransactionPipelineBase and QueryTransactionPipelineBase provide default transaction handling for commands and queries respectively, with the query pipeline explicitly setting NoTracking behavior. Additionally, IUnitOfWork and IUnitOfWork\<TContext\> interfaces are added to abstract database context and transaction management, while ExcludeFromMigrationsEntityTypeConfigurationBase offers a reusable pattern for excluding specific entity types from EF Core migrations.

src/Shopway.Persistence/Abstractions · medium confidence

Users will benefit from improved email delivery via the new MimeKit-based email sender, secure JWT-based authentication with Google OAuth2 support, and robust two-factor authentication using the Topt service. Additionally, the system now reliably tracks the current user's context, including their ID, username, and customer ID, across the application.

src/Shopway.Infrastructure/Services · high confidence

New interface contracts are added to the domain layer to standardize entity and value object implementations. This includes IAggregateRoot for managing domain events, IAuditable for tracking creation and update timestamps/users, ISoftDeletable for logical deletion, IUniqueKey for composite key queries, and IValueObject for immutable value types. Additionally, IDomainEvent and IEntityId interfaces are introduced to support Ulid-based identifiers and MediatR notifications.

src/Shopway.Domain/Common/BaseTypes/Abstractions · high confidence

A new authorization mechanism has been added for the generic proxy feature, allowing fine-grained control over which properties users can read via proxy queries. The system now enforces that a user must have the 'Read' permission for every property (including nested ones) referenced in a proxy query's mapping, filtering, and sorting configurations. This is implemented through a new \GenericProxyPropertiesRequirement\ and its corresponding handler, which validates user permissions against the specific properties requested in each query.

src/Shopway.Presentation/Authentication/GenericProxy · high confidence

The domain layer now enforces strict validation for product attributes through new value objects: Description, Price, ProductName, Revision, Stars, Title, and UomCode. Each type encapsulates its own business rules (e.g., length limits, allowed values, or ranges) and returns specific error messages, ensuring that invalid data cannot be instantiated within the domain model.

src/Shopway.Domain/Products/ValueObjects · high confidence

The domain layer now enforces strict validation for user-related data through new value objects: AccessToken, Address, Email, ExternalIdentityProvider, FirstName, LastName, Password, PasswordHash, PhoneNumber, RefreshToken, TwoFactorTokenHash, TwoFactorToptSecret, and Username. Each type encapsulates specific validation rules (e.g., length, format, or allowed values) and returns structured error information, ensuring that user data is always in a valid state before reaching the rest of the application.

src/Shopway.Domain/Users/ValueObjects · high confidence

The outbox implementation now includes an ExecutionStatus enum to track message states (InProgress, Failure, Success) and an OutboxMessage class that manages retry logic, error recording, and deserialization of domain events. This provides better visibility into message processing outcomes and supports more robust error handling for background tasks.

src/Shopway.Infrastructure/Outbox · medium confidence

The Shopway.Persistence module now includes dedicated exception classes for configuration and migration errors. Users will see ConfigurationException for configuration issues and MigrationException for database migration failures, both located in the Shopway.Persistence.Exceptions namespace.

src/Shopway.Persistence/Exceptions · high confidence

The persistence layer introduces a new specification pattern in \src/Shopway.Persistence/Specifications\ to centralize and standardize how database queries are constructed. A new \Specification\<TEntity, TEntityId\>\ class and its mapping variant \SpecificationWithMapping\ encapsulate query options (tracking, splitting, tags), filters, sorting, and includes. A \LikeProvider\ handles fuzzy search logic, while \SpecificationUtilities\ applies these specifications to \IQueryable\ objects, ensuring consistent application of filters, likes, sorting, and mapping. This refactors how data is fetched and transformed, moving away from scattered query building into a unified specification model.

src/Shopway.Persistence/Specifications · high confidence

The infrastructure layer now uses the Polly 8.0 API for defining resilience and retry policies. This introduces new \ResiliencePipeline\ configurations for general retries and database migrations, alongside utility methods to execute them and return standardized results. The legacy Polly 7.x style policies are retained as obsolete for backward compatibility.

src/Shopway.Infrastructure/Policies · high confidence

Add base classes for integration tests; Added architecture test utilities for enforcing coding standards; Added architecture tests for domain layer constraints; Added architecture tests for naming conventions; Added benchmark tests for reflection utilities; Added integration test fixtures for persistence layer; Added integration test for adding product reviews; Added integration test infrastructure and configuration; Added integration test infrastructure and documentation; Added integration test infrastructure for database persistence; Added integration test utilities for database, API, and response handling; Added integration tests for ProductController endpoints; Added integration tests for the ProductController; Added integration tests for the product review submission flow; Added performance test base classes for load testing; Added performance test project for load testing; Added performance test utilities and helpers; Added performance tests for the ProductsController; Added test collection definition for WebApplicationFactory; Added test collection fixtures for integration tests; Added test configuration classes for integration tests; Added test helper classes for controller response deserialization; Added test helper classes for deserializing API responses; Added test helper classes for product and review data generation; Added test infrastructure for API integration tests; Added test utilities for integration testing; Added test utility classes for ProductController integration tests; Added unit tests for Error and Result domain classes; Added unit tests for GetProductByIdQueryHandler; Added unit tests for Product domain logic; Added unit tests for domain utility classes; Added unit tests for domain value objects; Added unit tests for naming conventions; Added unit tests for the fuzzy search infrastructure; New test base classes and configuration options for integration tests.

The solution has been upgraded to .NET 8, replacing the previous .NET 6 target framework across all projects. This includes adding new project files for the application, domain, infrastructure, persistence, and presentation layers, as well as source generators and test projects. Key dependencies such as MediatR, FluentValidation, and various OpenTelemetry packages have been added or updated to support the new architecture.

(dependencies) · high confidence

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

• CAI 48 → 49 (+0.7)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 92 → 92 (-0.5)
• Architecture 74 → 82 (+7.4)
• Maturity 62 → 62 (+0.0)
• Readiness 31 → 30 (-0.9)
• Security 55 → 59 (+4.2)
• Domain Modelling 71 → 70 (-1.2)
• Event-Driven 100 → 100 (+0.0)
• Performance 69 → 69 (+0.0)

• Bounded contexts not declared
• Duplicated block (13 lines × 2) (src/Shopway.Application/Utilities/FluentValidationUtilities.cs)
• Duplicated block (14 lines × 2) (src/Shopway.Application/Cache/ApplicationCache.AllowedFilterOperations.cs)
• Duplicated block (9 lines × 2) (src/Shopway.Application/Features/Orders/Commands/AddOrderLine/AddOrderLineCommandValidator.Fluent.cs)
• Duplicated block (9 lines × 2) (src/Shopway.Domain/Common/Utilities/HashUtilities.cs)
• High CVE: MessagePack 2.4.59
• High CVE: MessagePack 2.4.59
• High CVE: Scriban.Signed 5.5.0
• High CVE: Scriban.Signed 5.5.0
• High CVE: Scriban.Signed 5.5.0
• High CVE: Scriban.Signed 5.5.0
• High CVE: Scriban.Signed 5.5.0
• High CVE: Scriban.Signed 5.5.0
• High CVE: Scriban.Signed 5.5.0
• High CVE: Scriban.Signed 5.5.0
• High CVE: System.Text.Json 8.0.0
• High CVE: System.Text.Json 8.0.0
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 34 more

• Change coupling: IProductRepository.cs ↔ CachedOrderHeaderRepository.cs (src/Shopway.Domain/Products/IProductRepository.cs)
• Change coupling: ProductOffsetPageQueryHandler.cs ↔ CachedProductRepository.cs (src/Shopway.Application/Features/Products/Queries/ProductOffsetPageStaticQuery/ProductOffsetPageQueryHandler.cs)
• Change coupling: ProductOffsetPageQueryHandler.cs ↔ ProductRepository.cs (src/Shopway.Application/Features/Products/Queries/ProductOffsetPageStaticQuery/ProductOffsetPageQueryHandler.cs)
• Change coupling: ProductRepository.cs ↔ SpecificationUtilities.cs (src/Shopway.Persistence/Repositories/ProductRepository.cs)
• Change-coupling hub: ProductDictionaryCursorPageQueryHandler.cs → ProductOffsetPageQueryHandler.cs, CachedProductRepository.cs, ProductRepository.cs (src/Shopway.Application/Features/Products/Queries/ProductDictionaryCursorPageQuery/ProductDictionaryCursorPageQueryHandler.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (11 lines × 2) (PaymentGateway/Cryptography/HashUtilities.cs)
• Duplicated block (11 lines × 2) (SourceGenerators/Shopway.SourceGenerator/Generators/EntityIdComparerGenerator/EntityIdComparerGenerator.cs)
• Duplicated block (11 lines × 2) (src/Shopway.Domain/Orders/OrderLineKeyJsonConverter.cs)
• Duplicated block (11 lines × 2) (src/Shopway.Presentation/FastEndpoints/Proxy/ProxyGroup.cs)
• Duplicated block (13 lines × 2) (src/Shopway.Application/Features/Orders/Commands/AddOrderLine/AddOrderLineCommandValidator.Fluent.cs)
• Duplicated block (13 lines × 2) (src/Shopway.Application/Features/Proxy/GenericValidators/GenericFluentValidationUtilities.cs)
• Duplicated block (13 lines × 2) (src/Shopway.Application/Features/Users/Commands/AddPermissionToRole/AddPermissionToRoleCommandHandler.cs)
• Duplicated block (14 lines × 2) (src/Shopway.Application/Utilities/FluentValidationUtilities.cs)
• Duplicated block (14 lines × 2) (src/Shopway.Presentation/Controllers/ProxyController.cs)
• Duplicated block (15 lines × 2) (src/Shopway.Application/Cache/ApplicationCache.AllowedFilterOperations.cs)
• Duplicated block (15 lines × 2) (src/Shopway.Presentation/Controllers/ProxyController.cs)
• Duplicated block (16 lines × 6) (src/Shopway.Presentation/FastEndpoints/Proxy/GenericProxyByIdQueryFastEndpoint.cs)
• …and 78 more

• Unchanged — 49 HTTP endpoints

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

dr-marek-jaskula/DomainDrivenDesignUniversity 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.