dotnet/eShop
51.2
Adequate · 12 November 2026
15.4k
lines of production code
C#
with JavaScript
8
measurements over time
What this system is
This system is a reference e-commerce application built on .NET 10 and .NET Aspire, orchestrating a microservices architecture for catalog management, order processing, and user identity. It provides a comprehensive backend that handles shopping baskets, inventory validation, and payment workflows via RabbitMQ event bus, while exposing versioned APIs for external consumption. The platform supports multiple client interfaces, including a Razor Components web storefront, .NET MAUI mobile apps, and a Blazor hybrid app, all integrated with AI-driven features like semantic search and a shopping assistant chatbot.
How it got here
2023 — Initial eShop scaffolding and AI integration
44 changes.
This period established the foundational architecture of the eShop reference application, introducing core microservices for ordering, cataloging, and identity alongside .NET MAUI and Blazor hybrid client apps. It implemented critical infrastructure using .NET Aspire for orchestration and integrated AI capabilities, including semantic search and a shopping assistant, via Ollama and OpenAI embeddings.
2024–2026 — Comprehensive test coverage expansion
4 changes.
This period focused on significantly broadening the project's test suite by introducing Playwright end-to-end tests for storefront user journeys and adding extensive unit and functional tests for application services, webhooks, and AppHost configurations. Concurrently, development tooling was hardened by updating WinGet configurations to enforce elevated security privileges and utilizing dedicated DSC resources for extension management.
Features
Add checkout page for shipping address collection
The checkout page is now available at /checkout, allowing authenticated users to review and submit their shipping address (street, city, state, zip code, and country) before placing an order. The form pre-populates fields from the user's HTTP claims when available, validates that the shopping cart is not empty, and redirects to the orders page upon successful submission. The layout is styled with design tokens and includes responsive adjustments for smaller screens.
src/WebApp/Components/Pages/Checkout · high confidence
Added build automation scripts for Azure Container Registry and multi-arch manifests
This change introduces two new PowerShell scripts to the build pipeline. The \queue-all.ps1\ script automates the creation of Azure Container Registry (ACR) build tasks for all eShop microservices (including Basket, Catalog, Identity, Ordering, and various Web/API Gateway services), linking them to specific Dockerfiles and Git branches. The \create-manifests.ps1\ script generates and pushes Docker multi-architecture manifests, allowing images to be tagged with platform-specific variants (linux-master, win-master, etc.) and unified under common tags (latest, master, dev) for easier consumption.
build · high confidence
Catalog API database schema and seeding infrastructure
The Catalog API now includes the Entity Framework Core infrastructure to manage its PostgreSQL database, including the \CatalogContext\, entity configurations for brands, types, and items, and a seed script that populates initial data and generates AI embeddings when enabled. The database schema supports vector embeddings (via the \vector(384)\ Postgres extension) for AI features, uses identity columns for primary keys, and includes an \IntegrationEventLog\ table to support reliable event publishing.
src/Catalog.API/Infrastructure · high confidence
Catalog API integration event handling and stock validation
The Catalog API now includes integration event infrastructure to coordinate with the Order service, specifically handling order status changes. It introduces event handlers for \OrderStatusChangedToAwaitingValidation\ and \OrderStatusChangedToPaid\ events. When an order enters the validation phase, the catalog service checks product availability and publishes either a stock confirmation or rejection event. Upon payment, it deducts the ordered units from the catalog inventory. This logic is supported by new event records (e.g., \OrderStockConfirmedIntegrationEvent\, \ProductPriceChangedIntegrationEvent\) and a dedicated service (\CatalogIntegrationEventService\) that ensures atomic persistence of catalog changes alongside event logging.
src/Catalog.API/IntegrationEvents · high confidence
Initial EventBus abstraction and registration infrastructure
The src/EventBus directory now provides the foundational abstractions for the application's eventing system, including the IEventBus and IIntegrationEventHandler interfaces, the IntegrationEvent base record, and configuration via EventBusSubscriptionInfo. It introduces a registration mechanism using .NET keyed services (AddKeyedTransient) to support multiple handlers for a single event type, along with extension methods to configure JSON serialization options and map event types for the underlying message broker.
src/EventBus · high confidence
Initial Identity API scaffolding with ASP.NET Core Identity and IdentityServer4
The Identity.API service is introduced as the new authentication and authorization component for the eShop platform. It is built on ASP.NET Core Identity for user management and Duende IdentityServer4 for OpenID Connect and OAuth 2.0 capabilities. The service configures an \ApplicationUser\ model that extends the default identity user to include payment card details (number, security code, expiration, holder name) and a full shipping address. IdentityServer is set up with in-memory stores for API resources (orders, basket, webhooks), API scopes, and clients (including web, mobile/MAUI, and Swagger UI clients). The database layer uses Entity Framework Core with PostgreSQL, featuring an initial migration that creates the standard Identity tables alongside the custom user profile fields. The application is configured to automatically apply database migrations on startup and uses a cookie policy to ensure compatibility with modern browser security requirements.
src/Identity.API · high confidence
Initial domain model for the Ordering service
This change introduces the core domain entities and events for the Ordering service within the Ordering.Domain layer. It defines the Buyer aggregate (including PaymentMethod and CardType) and the Order aggregate (including OrderItem and Address value objects), establishing the foundational data structures for managing customers, payment methods, and order lifecycles. Additionally, it adds a set of domain events (such as OrderStarted, OrderStatusChanged, and BuyerPaymentMethodVerified) to facilitate event-driven communication for order state transitions and payment verification.
Ordering.Domain · high confidence
Initial eShop AppHost orchestration with Aspire
The eShop application now uses .NET Aspire for local development and testing orchestration. This introduces a centralized AppHost that manages the lifecycle of backend services (Redis, RabbitMQ, PostgreSQL) and frontend apps (WebApp, WebhooksClient). It configures a YARP reverse proxy to route mobile client requests to the Catalog, Ordering, and Identity APIs, handling API versioning and path prefix stripping. The setup also includes optional integrations for Microsoft Foundry (OpenAI) and Ollama for AI capabilities, and ensures forwarded headers are enabled for all projects to support reverse proxy scenarios.
src/eShop.AppHost · high confidence
Initial implementation of RabbitMQ-based event bus with OpenTelemetry tracing
The src/EventBusRabbitMQ module introduces a new RabbitMQ event bus implementation that integrates with OpenTelemetry for distributed tracing. It adds configuration options for subscription client names and retry counts, registers the event bus via dependency injection, and implements message publishing and consumption with automatic trace context propagation and semantic convention tagging for RabbitMQ operations.
src/EventBusRabbitMQ · high confidence
Initial implementation of WebApp basket, ordering, and order-status services
The WebApp now includes the core service layer for shopping and order management. Users can add items to and manage their shopping basket via a new \BasketService\ and \BasketState\ that coordinate with the Basket API and Catalog. The checkout flow is supported by \BasketCheckoutInfo\ and \OrderingService\, which submit orders to the Ordering API. Additionally, users receive real-time order status updates through \OrderStatusNotificationService\ and its integration event handlers, while product images are served directly from the WebApp via \ProductImageUrlProvider\.
src/WebApp/Services · high confidence
Initial implementation of the Ordering service application layer
This change introduces the core application logic for the Ordering service, establishing a CQRS architecture with MediatR. It adds command handlers for the full order lifecycle (create, cancel, ship, and status updates like paid or stock-confirmed) and corresponding integration event handlers to react to external system signals. The implementation includes pipeline behaviors for validation, logging, and database transactions, as well as domain event handlers to synchronize order state with buyer and payment information.
src/Ordering.API/Application · high confidence
Initial infrastructure setup for Ordering API
This change introduces the initial infrastructure layer for the Ordering API, including a database seeder to populate predefined card types (Amex, Visa, MasterCard) and an identity service implementation that retrieves the current user's identity and name from the HTTP context.
src/Ordering.API/Infrastructure · high confidence
Initial release of eShop integration event logging and web components
This change introduces the initial codebase for the eShop application, adding a new \IntegrationEventLogEF\ library that provides Entity Framework Core-based persistence for integration events. This includes the \IntegrationEventLogEntry\ model, an \EventStateEnum\ to track publication status (NotPublished, InProgress, Published, PublishedFailed), and an \IntegrationEventLogService\ to manage saving, retrieving, and updating the state of events within database transactions, supported by a \ResilientTransaction\ utility for connection resiliency. Additionally, it adds the \WebAppComponents\ library, specifically introducing an \ItemHelper\ utility for generating item URLs and global Razor imports for the web UI layer.
src/IntegrationEventLogEF, src/WebAppComponents, src/WebAppComponents/Item · high confidence
Initial release of the .NET MAUI Blazor Hybrid storefront
This change introduces the \src/HybridApp\ project, a cross-platform mobile application built with .NET MAUI and Blazor. It provides a native storefront experience featuring a catalog browsing page with brand and type filtering, pagination, and detailed product views. The app utilizes a shared Blazor component library for the UI, connects to a local mobile backend-for-frontend (BFF) service for data, and includes the necessary platform-specific configurations for Android, iOS, MacCatalyst, Windows, and Tizen.
src/HybridApp · high confidence
Initial release of the Basket gRPC service
The Basket.API service is introduced as a new gRPC-based microservice that manages customer shopping baskets. It exposes RPC methods to get, update, and delete baskets, with data persisted in Redis via the \RedisBasketRepository\. The service integrates with the identity system to authenticate users and subscribes to \OrderStartedIntegrationEvent\ to automatically clear the basket when an order is placed.
src/Basket.API · high confidence
Initial release of the eShop .NET MAUI client application
This change introduces the complete eShop ClientApp, a cross-platform mobile application built with .NET MAUI. It provides the full user interface and navigation structure, including a Shell-based layout with Catalog, Map, and Profile tabs, alongside views for Login, Basket, Checkout, and Settings. The app includes a robust animation system (Fade, StoryBoard), custom UI controls (ToggleButton, AddBasketButton), and data converters. It integrates with backend services for catalog, basket, orders, and identity, supports GPS location tracking, and handles theming (light/dark mode) and app actions.
src/ClientApp · high confidence
Initial release of the eShop WebApp
The eShop WebApp is introduced as a new Razor Components application with interactive server-side rendering. It establishes the core application structure by registering service defaults, configuring the HTTP pipeline (including HSTS, antiforgery, and HTTPS redirection), and setting up static file serving. A key behavioral addition is the configuration of a URL forwarder that routes product image requests to the CatalogApi, allowing the API to remain private while images are served through the WebApp. The application also configures session cookie lifetime and event bus subscription settings via appsettings.
src/WebApp · high confidence
Initial repository scaffolding and configuration
The repository is initialized with the foundational structure for the eShop reference application, including the solution file (eShop.slnx), project definitions, and a global.json pinning the SDK to version 10.0.302. It introduces .NET Aspire as the orchestration layer, configured via an AppHost project and an aspire.config.json file, and sets up Playwright for end-to-end browser testing. The commit also establishes development standards through .editorconfig and .markdownlint.json, adds CI/CD pipelines (ci.yml), and provides essential documentation such as README.md, CONTRIBUTING.md, and CODE-OF-CONDUCT.md.
(repo-wide) · high confidence
Initial setup of Ordering API extension services and utilities
This change introduces the foundational extension methods and service registrations for the Ordering API. It adds DI configuration for the OrderingContext (using Npgsql), integration event services, MediatR behaviors (logging, validation, transaction), and RabbitMQ event bus subscriptions. Additionally, it includes utility extensions for mapping BasketItems to OrderItemDTOs, safe LINQ projection handling, and structured logging for order status and payment updates.
src/Ordering.API/Extensions · high confidence
Introduce AI embedding generation for catalog items
Added the ICatalogAI interface and CatalogAI service implementation to generate vector embeddings for catalog items and text. This new capability allows the catalog API to produce embeddings using an injected IEmbeddingGenerator, supporting downstream AI features like semantic search or recommendations, while gracefully handling cases where the AI provider is not configured.
src/Catalog.API/Services · high confidence
Introduce OrderProcessor and PaymentProcessor services
The application now includes two new background services: the OrderProcessor, which monitors for orders in a grace period and publishes confirmation events, and the PaymentProcessor, which handles stock-confirmation events to simulate payment success or failure. These services are wired to a RabbitMQ event bus and use PostgreSQL for order data, enabling the asynchronous processing of the order-to-payment workflow.
src/OrderProcessor · high confidence
Introduce Webhooks API for event-driven subscriptions
The Webhooks.API service is introduced to allow users to manage webhook subscriptions and receive notifications for specific system events. Users can now register, view, and delete webhook endpoints via a versioned REST API (v1) at \/api/webhooks\. The service listens for integration events—specifically \ProductPriceChanged\, \OrderStatusChangedToPaid\, and \OrderStatusChangedToShipped\—and forwards relevant payloads to subscribed URLs. To ensure security and validity, subscription creation requires a successful grant URL test (verifying origin and token via an OPTIONS request), and all endpoints are protected by authentication.
src/Webhooks.API · high confidence
Introduce catalog domain models and AI integration services
The Catalog API now includes a complete set of domain models (CatalogItem, CatalogBrand, CatalogType, CatalogFacets) and supporting infrastructure (PaginatedItems, PaginationRequest, CatalogServices). Notably, CatalogItem now features an optional Vector embedding property and inventory management methods (AddStock, RemoveStock), while CatalogServices explicitly injects an ICatalogAI service, indicating the introduction of AI-driven capabilities within the catalog domain.
src/Catalog.API/Model · high confidence
Introduce catalog service and UI helper components
The WebAppComponents library now includes a new CatalogService implementation that communicates with the backend catalog API endpoints (such as items, brands, types, and facets) via HttpClient, alongside the ICatalogService interface defining these capabilities. Additionally, an IProductImageUrlProvider interface is introduced to abstract product image URL generation, and a PriceFormatter utility is added to standardize monetary display formatting using invariant culture.
src/WebAppComponents/Services · high confidence
Introduce centralized service defaults and API versioning support
This change adds a new \eShop.ServiceDefaults\ library that standardizes cross-cutting concerns for eShop services. It provides default health checks, OpenTelemetry instrumentation (logging, metrics, tracing), and service discovery configuration. Authentication is standardized via JWT Bearer tokens with automatic access token propagation to downstream HTTP calls. Additionally, it integrates ASP.NET API Versioning and configures Scalar for API documentation, enabling versioned OpenAPI documents with OAuth2 security schemes and deprecation metadata.
src/eShop.ServiceDefaults · high confidence
Introducing the AdventureWorks AI Shopping Assistant
A new AI-powered shopping assistant is now available in the web application, allowing users to interact with a chatbot that can answer questions about the AdventureWorks catalog, search for products using semantic relevance, and add items directly to the shopping cart. The assistant is presented as a floating panel with a draggable header and resizable window, featuring a persistent launcher button with animated eyes. It leverages the Microsoft.Extensions.AI framework to connect to an underlying AI model (configured via Microsoft Foundry or Ollama) and processes markdown-formatted responses to display product images within the chat interface.
src/WebApp/Components/Chatbot · high confidence
New user account pages for login, logout, and order history
This change introduces the core user-facing pages for account management and order tracking. The new Login page handles authentication redirects and return URLs, while the Logout page provides the necessary endpoint for session termination. The Orders page displays a user's purchase history, including order numbers, dates, totals, and status badges (with specific styling for paid and cancelled states), and features an empty state for new users. Additionally, the OrdersRefreshOnStatusChange component enables real-time updates to the order list by subscribing to status change notifications and refreshing the view when an order's status changes.
src/WebApp/Components/Pages/User · high confidence
Ordering API initializes with ASP.NET API Versioning and structured configuration
The Ordering API now includes ASP.NET API Versioning, which adds 'api-supported-versions' and 'api-deprecated-versions' headers to all responses and exposes the Orders endpoint as versioned API V1. The service entry point (Program.cs) is established with standard middleware, including Problem Details and default OpenAPI support, while configuration files define connection strings for PostgreSQL and RabbitMQ, logging levels, and Identity scopes for Swagger UI authentication.
src/Ordering.API · high confidence
Behavioural changes
Catalog API endpoints now support versioning and enhanced filtering
The Catalog API has been refactored to support API versioning (v1 and v2) and includes new endpoints for semantic search and improved filtering. Users can now access catalog items via versioned routes (e.g., /api/catalog/v1/items, /api/catalog/v2/items) and utilize a new v2 semantic search endpoint (/api/catalog/v2/items/withsemanticrelevance) for AI-driven item discovery. The API also exposes facets for brand and type counts to support dynamic filtering in the storefront, and maintains existing CRUD operations for catalog items.
src/Catalog.API/Apis · high confidence
Catalog API introduces versioned endpoints with OpenAPI documentation
The Catalog API now supports explicit API versioning (v1 and v2), requiring clients to pass an api-version query parameter to access endpoints. This change introduces distinct behavior for v2, which adds an UpdateItem operation, while v1 remains read-only for item retrieval. To support this, the service now generates and serves OpenAPI documents for both versions (v1.json and v2.json) and includes API version headers in responses, allowing consumers to discover and interact with the correct API contract.
src/Catalog.API · high confidence
Catalog API now supports Ollama embeddings and build-time OpenAPI generation
The Catalog API's service registration has been updated to conditionally enable AI embedding capabilities via Ollama when the 'OllamaEnabled' configuration flag is set, falling back to OpenAI if a connection string is present. Additionally, the application now detects build-time OpenAPI document generation scenarios (via the 'Build' environment or 'GetDocument.Insider' tool) to skip database migrations and connection setup, ensuring faster and safer static analysis.
src/Catalog.API/Extensions · high confidence
Centralized WebApp service configuration and AI integration
The WebApp now consolidates its dependency injection setup in a new Extensions class, configuring authentication via OpenID Connect and cookies, registering gRPC and HTTP clients for Basket, Catalog, and Ordering APIs with automatic API versioning, and setting up event bus subscriptions for order status notifications. Additionally, it introduces flexible AI service integration that automatically configures either an Ollama client or an OpenAI chat client based on configuration settings, enabling users to leverage AI features without requiring public exposure of the Catalog API.
src/WebApp/Extensions · high confidence
Introduce minimal API endpoints for order management with credit card masking
The Ordering API now exposes order-related endpoints (create, cancel, ship, get) via minimal APIs in \OrdersApi.cs\, replacing previous implementations. A key behavioral change in the order creation flow is that the credit card number is masked (showing only the last 4 digits) before being logged or passed to the command handler, addressing a security concern regarding sensitive data exposure in logs. The API also integrates ASP.NET API Versioning, exposing these endpoints under the \api/orders\ group with version 1.0.
src/Ordering.API/Apis · high confidence
Introduce modern storefront layout and navigation components
The web application now features a redesigned storefront layout with a sticky top bar, a dynamic hero section, and a comprehensive footer. The HeaderBar component displays the AdventureWorks brand, a primary navigation link, and user/cart controls, while the hero section adapts its height and imagery based on the current page (e.g., compact for product details). The FooterBar provides brand information, social media links, and structured navigation columns for Shop, Support, and Company sections. Additionally, the CartMenu component now visually indicates the number of items in the shopping bag with a count badge, and the UserMenu allows authenticated users to view their profile and log out. These changes establish a consistent, responsive visual foundation for the application.
src/WebApp/Components/Layout · high confidence
Introduce modernized catalog browsing with responsive filtering and product cards
The catalog UI has been modernized with a design-token foundation, introducing a new \CatalogSearch\ component for filtering products by brand and type with live counts, and a \CatalogListItem\ component for displaying products with a 3D tilt effect and scroll-reveal animations. The layout is now responsive, with filters collapsing to a full-width collapsible section on smaller screens, and product images are served directly from the WebApp to avoid exposing the CatalogApi.
src/WebAppComponents/Catalog · high confidence
Modernized storefront assets and interactive behaviors
The storefront assets have been updated to use the Plus Jakarta Sans and Open Sans typefaces, and the visual identity has been renamed to AdventureWorks with new header and footer logos. The interface now includes a set of SVG icons for navigation and actions, and the shopping experience is enhanced with client-side JavaScript: product cards feature a 3D tilt effect on hover, the cart allows immediate quantity updates via typing, the catalog grid supports client-side sorting with persisted preferences, and a floating shopping-assistant dock provides a resizable, draggable chat interface.
src/WebApp/wwwroot · high confidence
Order status stored as string instead of lookup table
The Ordering service now persists order status as a string column in the orders table rather than referencing a separate orderstatus lookup table. This migration drops the orderstatus table and the OrderStatusId foreign key, replacing them with a direct OrderStatus string column, which simplifies the data model and removes the need for a join when retrieving order status.
src/Ordering.Infrastructure · high confidence
Redesigned storefront with responsive, accessible shopping bag and product pages
The Cart, Catalog, and Item pages have been rebuilt with a modern, responsive design foundation. The Shopping Bag now features a segmented quantity stepper, improved accessibility labels, and a streamlined checkout summary. Product detail pages include a native image lightbox for zooming, sticky buy panels, and intelligent 'Back to catalog' navigation that preserves previous filters. The Catalog page offers a refined sorting interface and skeleton loading states. All pages utilize CSS design tokens for consistent theming and improved readability across devices.
src/WebApp/Components/Pages/Cart · high confidence
Updated WinGet configuration files and added security suppressions
The WinGet configuration files for Visual Studio and Visual Studio Code have been reorganized into the .config directory and updated to explicitly require elevated privileges (securityContext: elevated) for installing packages and enabling features like Developer Mode and WSL. The Visual Studio Code configuration has been significantly expanded to use dedicated DSC resources for installing specific extensions (Azure Developer CLI, WSL, Dev Containers, Docker, C\# DevKit, and .NET MAUI) instead of a generic script, and new CredScan suppression rules have been added to handle dummy credentials used in development.
.config · high confidence
WebhookClient rewritten as a Blazor Server app with authentication and webhook management UI
The WebhookClient has been rewritten as a Blazor Server application, replacing its previous implementation. This introduces a new user interface for managing webhook subscriptions, including a home page to view registered webhooks and received messages, and an 'Add Webhook' page to register new subscriptions. The app now supports user authentication via OpenID Connect with cookie-based sessions, featuring login and logout endpoints. It also includes a thread-safe in-memory repository for storing received webhook messages and integrates with the Webhooks API to handle registration and message reception, complete with token validation.
src/WebhookClient · high confidence
Test coverage
Add Playwright end-to-end tests for storefront flows; Added functional tests for the Ordering API; Added functional tests for the Redis-based basket repository; Added unit and functional tests for application services and webhooks API; Added unit tests for AppHost configuration and extension behavior; Added unit tests for Basket and Ordering services; Initial unit test suite for ClientApp services and view models.
Dependencies
Upgrade to .NET 10 and .NET Aspire 13.5.3
The application has been upgraded to target .NET 10.0 across all services, APIs, and client applications, including the MAUI-based ClientApp and HybridApp. The infrastructure and orchestration layer has been updated to .NET Aspire 13.5.3, bringing in corresponding updates for hosting providers (PostgreSQL, Redis, RabbitMQ, Yarp, Azure App Containers) and telemetry packages (OpenTelemetry, Scalar). This change also introduces centralized package version management via Directory.Packages.props and updates key dependencies such as Duende IdentityServer to 7.3.x, Grpc.Tools to 2.80.0, and IdentityModel to 7.0.0.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 50 → 51 (+1.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 60 → 60 (+0.2)
- Architecture 80 → 79 (-0.8)
- Maturity 66 → 68 (+2.6)
- Readiness 62 → 62 (+0.7)
- Security 63 → 60 (-2.7)
- Domain Modelling 53 → 51 (-1.4)
- Event-Driven 80 → 68 (-12.4)
- Accessibility 41 → 44 (+3.4)
- Performance 70 → 100 (+29.6)
Resolved (21)
- Documentation: no contributor guidance (README.md)
- Projects may be oversized for their cohesion
- XML-doc coverage: Basket.API (src/Basket.API/Basket.API.csproj)
- XML-doc coverage: Catalog.API (src/Catalog.API/Catalog.API.csproj)
- XML-doc coverage: ClientApp(net10.0-android) (src/ClientApp/ClientApp.csproj)
- XML-doc coverage: EventBus (src/EventBus/EventBus.csproj)
- XML-doc coverage: EventBusRabbitMQ (src/EventBusRabbitMQ/EventBusRabbitMQ.csproj)
- XML-doc coverage: HybridApp(net10.0-android) (src/HybridApp/HybridApp.csproj)
- XML-doc coverage: Identity.API (src/Identity.API/Identity.API.csproj)
- XML-doc coverage: IntegrationEventLogEF (src/IntegrationEventLogEF/IntegrationEventLogEF.csproj)
- XML-doc coverage: OrderProcessor (src/OrderProcessor/OrderProcessor.csproj)
- XML-doc coverage: Ordering.API (src/Ordering.API/Ordering.API.csproj)
- XML-doc coverage: Ordering.Domain (src/Ordering.Domain/Ordering.Domain.csproj)
- XML-doc coverage: Ordering.Infrastructure (src/Ordering.Infrastructure/Ordering.Infrastructure.csproj)
- XML-doc coverage: PaymentProcessor (src/PaymentProcessor/PaymentProcessor.csproj)
- XML-doc coverage: WebApp (src/WebApp/WebApp.csproj)
- XML-doc coverage: WebAppComponents (src/WebAppComponents/WebAppComponents.csproj)
- XML-doc coverage: WebhookClient (src/WebhookClient/WebhookClient.csproj)
- XML-doc coverage: Webhooks.API (src/Webhooks.API/Webhooks.API.csproj)
- XML-doc coverage: eShop.AppHost (src/eShop.AppHost/eShop.AppHost.csproj)
- …and 1 more
New (42)
- Basket: 2 contract type(s) expose producer-owned ids/enums
- Catalog: 1 contract type(s) expose producer-owned ids/enums
- Edited copies of one member (3 members, 14+ corresponding lines) (src/HybridApp/Services/CatalogService.cs)
- Edited copies of one member (3 members, 16+ corresponding lines) (src/ClientApp/Services/RequestProvider/RequestProvider.cs)
- Edited copies of one member (3 members, 8+ corresponding lines) (src/Ordering.API/Application/Validations/CancelOrderCommandValidator.cs)
- Edited copies of one member (3 members, 9+ corresponding lines) (src/Ordering.API/Application/DomainEventHandlers/OrderStatusChangedToAwaitingValidationDomainEventHandler.cs)
- Edited copies of one member (4 members, 14+ corresponding lines) (src/Ordering.API/Application/IntegrationEvents/EventHandling/GracePeriodConfirmedIntegrationEventHandler.cs)
- Edited copies of one member (4 members, 24+ corresponding lines) (src/ClientApp/Extensions/VisualElementExtensions.cs)
- Edited copies of one member (5 members, 5+ corresponding lines) (src/Ordering.API/Application/DomainEventHandlers/OrderCancelledDomainEventHandler.cs)
- Edited copies of one member (6 members, 10+ corresponding lines) (src/Ordering.API/Application/Commands/CancelOrderCommandHandler.cs)
- Edited copy of a member (11 corresponding lines) (src/ClientApp/Services/Basket/BasketService.cs)
- Edited copy of a member (15 corresponding lines) (src/ClientApp/Services/Order/OrderService.cs)
- Edited copy of a member (16 corresponding lines) (src/ClientApp/Services/RequestProvider/RequestProvider.cs)
- Edited copy of a member (21 corresponding lines) (src/Basket.API/Grpc/BasketService.cs)
- Edited copy of a member (22 corresponding lines) (src/ClientApp/ViewModels/CatalogViewModel.cs)
- Edited copy of a member (24 corresponding lines) (src/ClientApp/Extensions/VisualElementExtensions.cs)
- Edited copy of a member (24 corresponding lines) (src/ClientApp/Extensions/VisualElementExtensions.cs)
- Edited copy of a member (24 corresponding lines) (src/Ordering.API/Apis/OrdersApi.cs)
- Edited copy of a member (29 corresponding lines) (src/ClientApp/Services/FixUri/FixUriService.cs)
- Edited copy of a member (35 corresponding lines) (src/Identity.API/Quickstart/Consent/ConsentController.cs)
- …and 22 more
API surface
- Unchanged — 31 HTTP endpoints
Architecture
- Unchanged — 19 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
dotnet/eShop was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 12 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 913acea66708a59595351174cee9b29f37179d29 — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.42+preprod-6bc2a431cb25.