charlessolar/eShopOnContainersDDD

This system is a distributed e-commerce platform built on .NET 6, organized into distinct business contexts for Catalog, Identity, Ordering, Basket, and Payment. It employs an event-driven architecture using NServiceBus and RabbitMQ to synchronize state across multiple data stores, specifically MongoDB for document persistence and Elasticsearch for read-optimized search and analytics. The application exposes these capabilities through dedicated ASP.NET Core REST APIs secured with JWT authentication, while a React Single Page Application serves as the frontend interface.

The Infrastructure layer now includes a generic Enumeration base class that provides value-based equality, comparison, and lookup capabilities (by value or display name) for strongly-typed enumerations. A corresponding Newtonsoft.Json converter is added to seamlessly serialize and deserialize these Enumeration types, ensuring they are handled correctly during data exchange. Additionally, project metadata has been updated to reflect the new repository URL and copyright year, and assembly info generation is configured to use a shared file.

src · high confidence

New NServiceBus message handlers have been introduced in the Ordering context to manage buyer lifecycle and associated entities. The Buyer handler processes commands to initiate a buyer profile, mark standing status (good or suspended), and set preferred address or payment method. Dedicated handlers for Address and PaymentMethod entities now support adding and removing these items, allowing users to manage their shipping addresses and credit card details within the ordering system.

src/Contexts/Ordering/Domain/Handlers/Buyer · high confidence

New NServiceBus handlers have been introduced for CatalogBrand and CatalogType, enabling the system to process Define and Destroy commands. These handlers allow users to create new brand and type entities or remove existing ones via asynchronous message processing, integrating with the underlying aggregate root structure.

src/Contexts/Catalog/Domain/Handlers/CatalogBrand, src/Contexts/Catalog/Domain/Handlers/CatalogType · high confidence

A new logging infrastructure component has been introduced to automatically capture details of incoming and outgoing NServiceBus messages. This addition includes two pipeline behaviors, IncomingLoggingMessageBehavior and OutgoingLoggingMessageBehavior, which log the message type, body content, and associated headers at the Debug level, providing enhanced visibility into message flow for troubleshooting and monitoring.

src/Infrastructure/Logging · high confidence

A new handler has been introduced to manage payment method data within the Elastic search context. It processes queries to retrieve payment methods by ID or search by alias, cardholder name, and card type using autocomplete matching, and it listens for domain events to add or remove payment method records from the index, ensuring the search store stays in sync with the domain state.

src/Contexts/Ordering/Applications/Elastic/Buyer/Entities/PaymentMethod · high confidence

A new service has been added to retrieve the list of users associated with a specific role. This component listens for role assignment and revocation events to maintain an up-to-date mapping of users to roles in the database, and exposes a query interface to fetch the current user list for any given role ID.

src/Contexts/Identity/Applications/MongoDb/User/Services · high confidence

This change introduces new application-layer components in the Basket context to maintain read-optimized indexes in both Elasticsearch and MongoDB. It adds event handlers (BasketIndex, BasketItemIndex, and BasketsUsingProduct) that keep these indexes synchronized with domain events such as item additions, removals, quantity updates, and catalog price or description changes. An Elastic setup class configures the corresponding indices with autocomplete analyzers. To support this new code, a suite of unit tests is added to verify the correct creation, update, and deletion of basket and basket-item records in both storage backends.

src/Contexts/Basket/Applications · high confidence

New domain handlers have been added to the Basket context to process specific basket operations. The item handler manages adding, removing, and updating the quantity of products within a basket, including fetching catalog product details. The main basket handler manages the basket's lifecycle by initiating new baskets, claiming existing ones for a user, and destroying baskets.

src/Contexts/Basket/Domain/Handlers/Basket · high confidence

The Catalog application layer now includes dedicated event handlers and query processors for both ElasticSearch and MongoDB backends. For ElasticSearch, new handlers manage CatalogBrand, CatalogType, and Product data, enabling search capabilities by brand, type, name, and description, while a setup class initializes the necessary indices with custom analyzers. For MongoDB, corresponding handlers synchronize product, brand, and type state changes (add, update, remove) to the document store, ensuring data consistency across both persistence mechanisms.

src/Contexts/Catalog/Applications · high confidence

The Identity application now automatically creates and configures Elasticsearch indices for Role, User, and UserRoles data upon initialization. This setup defines specific mappings and analysis settings, including NGram tokenization for text search, ensuring that identity-related data is properly indexed for efficient querying within the system.

src/Contexts/Identity/Applications/Elastic · high confidence

Buyer address data is now kept in sync with the Elasticsearch index. The new handler processes domain events to automatically add new addresses and remove deleted ones from the search store, and it exposes a query endpoint that allows users to search for addresses by username or perform autocomplete searches across fields like alias, street, city, state, country, and zip code.

src/Contexts/Ordering/Applications/Elastic/Buyer/Entities/Address · high confidence

A new handler has been added to keep Elasticsearch in sync with order item changes. It processes events such as Drafted, Added, PriceOverridden, and Removed to create, update, or delete corresponding items in the search index, and also supports querying order items by order ID.

src/Contexts/Ordering/Applications/Elastic/Order/Entities · high confidence

The identity context now maintains an Elasticsearch index of users by reacting to domain events. A new handler processes user registration, enable/disable status changes, and role assignments or revocations, ensuring that the search index stays consistent with the identity store.

src/Contexts/Identity/Applications/Elastic/User · high confidence

The query models in the Ordering context have been updated to support more granular data retrieval. The Orders query now inherits from a Paged base class and includes properties for filtering by order status and date range (From/To). Additionally, new query models have been introduced: BuyerOrders allows filtering by username, status, and date range; Sales, SalesByState, and SalesWeekOverWeek queries all support date range filtering and pagination; and a new Order query enables retrieval by specific order ID. These changes enable the UI to filter and paginate order and sales data more effectively.

src/Contexts/Ordering/Language/Order/Queries · high confidence

A new service implementation has been added to handle role-based user management within the Identity context. This component listens for role assignment and revocation events to automatically maintain a mapping of users to their roles in the underlying store. It also exposes a service endpoint that allows other parts of the system to retrieve the list of users associated with a specific role.

src/Contexts/Identity/Applications/Elastic/User/Services · high confidence

The identity context has been restructured to introduce dedicated models, commands, and events for managing users and roles. This change adds the ability to register, identify, and change user details (name, password), as well as enable or disable user accounts. It also introduces role definitions, allowing roles to be created, activated, deactivated, and destroyed, with the capability to assign or revoke roles for specific users. These changes provide the foundational domain logic for user authentication and authorization within the application.

src/Contexts/Identity/Language · high confidence

The Identity context now includes core domain entities for managing users and roles. The User entity supports registration, authentication (identify), account enable/disable, and profile updates (name and password changes), with passwords handled via hashing. The Role entity manages role lifecycle states (define, activate, deactivate, destroy, revoke) and enforces business rules. A separate Role entity within the User context handles the assignment and revocation of roles to specific users.

src/Contexts/Identity/Domain/Entities · high confidence

This change introduces the core domain entities for the Catalog context, specifically Brand, CatalogType, and Product. These entities implement an aggregate-root pattern using event sourcing, where state changes (such as defining a brand, adding a product, setting pictures, updating prices, or managing stock thresholds) are captured as domain events. The Product entity includes specific business logic for reordering states and stock management, establishing the foundational data model for catalog operations.

src/Contexts/Catalog/Domain/Entities · high confidence

This change introduces the core domain entities for the Ordering context, including Buyer, Address, PaymentMethod, Order, and OrderItem. Users can now define buyers with preferred addresses and payment methods, and create orders that track their lifecycle through drafting, payment, shipping, and cancellation states, while also supporting address and payment method updates.

src/Contexts/Ordering/Domain · high confidence

This change introduces the foundational structure for the new Payment service. It defines the core domain model, including the Payment aggregate entity and its lifecycle events (Charged, Settled, Canceled), along with the corresponding commands and status enumerations. The service integrates with Elasticsearch to index and query payment records, handling event-driven updates to maintain the payment status. Additionally, it sets up the ASP.NET Core presentation layer with REST API controllers, Swagger documentation, JWT authentication, and health checks, while also configuring NServiceBus with RabbitMQ for message handling.

src/Contexts/Payment · high confidence

This change introduces the presentation layer for the Basket service, providing the HTTP API entry point for managing shopping baskets. It includes a \BasketController\ exposing endpoints for listing, retrieving, initializing, claiming, and destroying baskets, secured via JWT Bearer authentication. The service is configured with Swagger UI for API documentation, global exception handling, and model state validation. It also features health check endpoints (\/hc\, \/liveness\) and integrates with RabbitMQ for messaging. A \FailingMiddleware\ is included to support testing by allowing controlled failure injection.

src/Contexts/Basket/Presentation · high confidence

This change introduces the initial structure for the application's frontend and infrastructure layers. The \Frontend\ project is added as an ASP.NET Core application hosting a React Single Page Application (SPA) bootstrapped with Create React App, including a \WeatherForecast\ API endpoint and client-side components for navigation, data fetching, and service worker registration. Additionally, new interfaces are defined in the \Infrastructure\ layer to support query operations (including field definitions, sorting, and grouping) and to abstract database unit-of-work implementations for Elastic and MongoDB.

(repo-wide) · high confidence

The Domain service is now available as a standalone endpoint that connects to RabbitMQ using a quorum topology and persists events to an EventStore. It includes a message mutator that automatically propagates correlation stamps between commands and events to maintain context across distributed operations, and configures structured logging for both incoming and outgoing messages.

src/Endpoints/Domain · high confidence

Adds a new standalone Elastic endpoint service that connects to an Elasticsearch cluster and RabbitMQ to index and query domain documents. The implementation includes a Dockerfile for containerization, an entry point that configures NServiceBus, Aggregates.NET, and the Elasticsearch client, and a Unit of Work class that manages bulk indexing, updates with versioning, and complex queries (including autocomplete support) against the 'eShop' index.

src/Endpoints/Elastic · high confidence

Adds a new MongoDB endpoint service that implements the event store interface using a Unit of Work pattern. The service manages document persistence (inserts, updates, deletes) in MongoDB collections, handling both string and Guid-based document IDs, and integrates with RabbitMQ for messaging and Serilog for structured logging. A Dockerfile is included to containerize the service using .NET 6.

src/Endpoints/MongoDb · high confidence

This change adds the domain event handlers for the Ordering context, enabling users to create, modify, and track orders. The main Order handler processes commands to draft, confirm, pay, ship, and cancel orders, as well as update shipping/billing addresses and payment methods. A separate Item handler allows adding, removing, and overriding prices for items within an order.

src/Contexts/Ordering/Domain/Handlers/Order · high confidence

The application now includes a new \PasswordStorage\ class in the security infrastructure that handles password hashing and verification using PBKDF2 with SHA-1. This implementation generates random salts and stores credentials in a structured format (algorithm:iterations:hashSize:salt:hash), allowing for future algorithm upgrades without invalidating existing hashes. Users benefit from improved security practices for credential storage, although the reliance on SHA-1 may be considered less robust than modern alternatives like bcrypt or Argon2.

src/Infrastructure/Security · high confidence

New NServiceBus message handlers have been added for the Buyer context to synchronize MongoDB storage with domain events. The Address handler now persists address details (including the newly added alias) and removes them upon removal events, while the PaymentMethod handler similarly persists payment method details (including cardholder name, number, expiration, security number, and card type) and handles deletions. This ensures that the MongoDB-backed read model for buyer addresses and payment methods stays consistent with the underlying event stream.

src/Contexts/Ordering/Applications/MongoDb/Buyer/Entities · high confidence

New application handlers have been added to persist Buyer and Order data in MongoDB. The Buyer handler synchronizes buyer status (Initiated, InGoodStanding, Suspended) and preferred address/payment settings. The Order handler manages the full order lifecycle, including creating orders from basket data (capturing billing/shipping addresses and payment methods), updating status through Drafted, Confirmed, Paid, and Shipped states, and handling address or payment method changes.

src/Contexts/Ordering/Applications/MongoDb/Order · high confidence

This change introduces new event handlers and query processors in the Ordering context to maintain denormalized read models in Elasticsearch. Specifically, it adds support for querying orders by buyer (BuyerOrders) and general orders (Orders), as well as new sales analytics models for total sales (Sales), sales by state (SalesByState), and week-over-week sales trends (SalesWeekOverWeek). These handlers listen to order lifecycle events (Drafted, Canceled, Paid, Shipped, etc.) and item changes to keep the read-side data consistent, enabling the UI to display order lists and dashboard charts efficiently.

src/Contexts/Ordering/Applications/Elastic/Order · high confidence

The infrastructure layer now includes a new query builder system that supports advanced search capabilities, including autocomplete and grouped logical operations. This change introduces new enumeration types for Group (All, Any, Not) and Operation (Equal, NotEqual, GreaterThan, etc., including Autocomplete), along with a QueryBuilder class that allows constructing complex query definitions with field-level boosts and grouping logic.

src/Infrastructure · high confidence

The Identity context now includes domain handlers for managing user accounts and role assignments. The new \User/Handler.cs\ processes commands to register users, change their name or password, authenticate them, and enable or disable accounts. Additionally, \Role/Handler.cs\ handles the lifecycle of roles (defining, activating, deactivating, destroying, revoking), while \User/Entities/Role/Handler.cs\ manages the assignment and revocation of specific roles to individual users. These changes enable the backend to support core identity operations such as user registration, authentication, and role-based access control.

src/Contexts/Identity/Domain/Handlers/User · high confidence

A new handler has been introduced to process payment-related commands. It now supports charging a payment by validating buyer and order states, settling a payment, and canceling a payment, ensuring that these core payment lifecycle actions are properly routed and executed within the payment context.

src/Contexts/Payment/Domain/Handlers/Payment · high confidence

The catalog system now processes a comprehensive set of product management commands, including adding new items, removing products, and updating details such as name, description, price, and picture. It also supports stock management operations like updating stock levels and setting restock/max stock thresholds, as well as tracking reorder status through mark and unmark actions.

src/Contexts/Catalog/Domain/Handlers/Product · high confidence

New message handlers have been introduced for both the Elastic and MongoDB identity contexts to synchronize role state changes. These handlers process domain events (Activated, Deactivated, Defined, Destroyed, Revoked) to update role records in the respective data stores. Specifically, the handlers manage role enablement/disabling, creation, deletion, and the removal of role assignments from associated users when a role is revoked.

src/Contexts/Identity/Applications/Elastic/Role, src/Contexts/Identity/Applications/MongoDb/Role · high confidence

This change introduces the initial presentation layer scaffolding for the Catalog, Identity, and Ordering contexts. It adds empty ASP.NET Core controllers (e.g., CatalogBrand, Product, User, Role) that define the API surface with routes, authorization requirements, and HTTP method signatures, though the business logic implementations are currently unpopulated. Additionally, it establishes the foundational web host configuration, including Program.cs and Startup.cs files, which wire up JWT authentication, Swagger documentation, health checks, and a 'FailingMiddleware' for testing purposes. Dockerfiles and launch settings are also provided to support containerized development and local debugging for these services.

src/Contexts/Catalog/Presentation, src/Contexts/Identity/Presentation, src/Contexts/Ordering/Presentation · high confidence

The FluentValidation integration for validating incoming commands has been removed from the infrastructure layer. This change deletes the \FluentValidationBehavior\ that previously intercepted NServiceBus messages to run validators, the \StructureMapValidatorFactory\ that resolved validators via the StructureMap container, and the \ValidationExtensions\ helper for custom rules. As a result, automatic validation of commands via FluentValidation is no longer performed by this component.

src/Infrastructure/Validation · high confidence

The legacy TodoMVC application, including its React components (Header, Footer, TodoItem, TodoList, TodoTextInput), MobX stores (TodoStore, RouterStore), and associated routing and styling, has been removed from the web client.

src/Web/src · high confidence

The Basket domain now enforces a business rule that prevents a basket from being claimed if it has already been claimed, using the new Rule() method on entities. This change is accompanied by the addition of domain entities (Basket, Item) and corresponding unit tests that verify the creation, destruction, claiming, and item management behaviors.

src/Contexts/Basket/Domain · high confidence

The basket domain models and commands have been refactored to identify items by ProductId rather than a separate ItemId, simplifying the AddItem, RemoveItem, and UpdateQuantity commands by removing the ItemId and Quantity fields where appropriate. The BasketItem model now uses long integers for price and quantity instead of decimals, and includes product picture details as base64 strings. Additionally, the BasketIndex model was renamed from Bucket and now tracks total item count, while the State class now handles Initiated and BasketClaimed events to set the user name.

src/Contexts/Basket/Language · high confidence

The buyer context now identifies users by string usernames instead of Guid buyer IDs, affecting commands (Initiate, SetPreferredAddress, SetPreferredPaymentMethod, MarkGoodStanding, MarkSuspended), events (Initiated, PreferredAddressSet, PreferredPaymentSet, InGoodStanding, Suspended), and entity models (Address, PaymentMethod). Address and payment method entities now support an alias field, and queries for addresses and payment methods support paging and term-based search. The buyer model exposes preferred address and payment method IDs, and the buyer index model provides summary metrics like total spent and orders.

src/Contexts/Ordering/Language/Buyer · high confidence

The buyer index in the Ordering context is now kept in sync with order lifecycle events. When a buyer initiates, changes standing, or updates preferred address/payment, the index is updated immediately. Additionally, order events (Drafted, Paid, Canceled) now adjust the buyer's total order count and total spent amount, ensuring the buyer profile reflects current order activity.

src/Contexts/Ordering/Applications/Elastic/Buyer · high confidence

The Catalog context has been restructured to support more granular product lifecycle management and improved data representation. Product picture storage has shifted from binary arrays to base64 strings, and product pricing now uses integer values (long) instead of decimals to avoid floating-point precision issues. The domain model now explicitly tracks reorder status via a boolean flag and introduces commands and events for updating stock levels and restock thresholds. Additionally, the internal naming has been corrected (e.g., 'CatagoryBrand' to 'CatalogBrand') and the product model has been renamed to 'CatalogProduct' to better reflect its role within the catalog system.

src/Contexts/Catalog/Language · high confidence

The Ordering context now initializes Elasticsearch indices for Buyers, Addresses, Payment Methods, and Orders. This setup introduces custom autocomplete analyzers (including edge n-gram, shingle, and snowball variants) to improve search capabilities for text fields such as buyer names, addresses, and product details. The index mappings define specific field types (Keyword, Text, Number, Date, Boolean) and configure settings like shard counts and replica numbers for the new indices.

src/Contexts/Ordering/Applications/Elastic · high confidence

Query replies now include an ElapsedMs property to track processing time, providing visibility into performance. A new ErrorResponse model has been introduced to standardize how error messages and developer details are returned to clients. Additionally, the Paged response model has been updated with necessary namespace imports to support its structure.

src/Infrastructure/Queries, src/Infrastructure/Responses · high confidence

A new handler has been added to the Identity context to keep the MongoDB user store in sync with domain events. It now responds to user registration, name changes, and enable/disable status updates, and it also processes role assignment and revocation events to maintain the user's role list in the database.

src/Contexts/Identity/Applications/MongoDb/User · high confidence

This update introduces several new helper classes in the Infrastructure layer, including ArrayExtensions, DateTimeExtensions, and EnumerableExtensions for common data manipulation, alongside a new AppSetup framework for managing application initialization sequences with dependency tracking. It also adds DIExtensions for dynamic assembly loading. On the behavioral side, the command bus now strictly validates responses, throwing a RejectedException if a command is rejected or encounters an error, and corrects message routing by capitalizing destination names (e.g., 'domain' to 'Domain'). Logging has been enhanced to explicitly set the SourceContext for better traceability.

src/Infrastructure/Extensions · high confidence

The ordering context's item model and related commands/events have been updated to support overriding item prices and tracking additional fees. The \Item\ model (renamed to \OrderingOrderItem\) now uses \long\ for price and quantity, adds fields for product picture content/type, description, and explicit price overrides, and calculates subtotals and totals including additional fees and taxes. Commands like \ChangeQuantity\ have been replaced by \OverridePrice\ to handle price changes, and events such as \QuantityChanged\ are now \PriceOverridden\. Additionally, \ItemId\ references in commands and events have been standardized to \ProductId\, and the \Items\ query class now inherits from \Paged\ to support pagination.

src/Contexts/Ordering/Language/Order/Entities · high confidence

The core Order model (renamed to OrderingOrder) now distinguishes between shipping and billing addresses, each with their own city, state, zip, and country fields, replacing the previous single address structure. Financial calculations have shifted from decimal to long types, incorporating additional fees and taxes, while tracking total items and quantity via derived properties. New Created and Updated timestamp fields and a Paid status flag have been added. Additionally, new models (SalesChart, SalesByState, SalesWeekOverWeek) have been introduced to support sales analytics dashboards, and a new OrderIndex model has been created to structure order data for search indexing.

src/Contexts/Ordering/Language/Order/Models · high confidence

The order processing logic has been updated to distinguish between billing and shipping addresses. The \ChangeAddress\ command and \AddressChanged\ event now include separate \ShippingId\ and \BillingId\ fields, replacing the previous single \AddressId\. Similarly, the \Draft\ command and \Drafted\ event have been expanded to include \ShippingAddressId\, \BillingAddressId\, and \PaymentMethodId\, while switching from \BuyerId\/\CartId\ to \UserName\/\BasketId\. These changes allow users to specify different delivery and payment details when creating or modifying an order.

src/Contexts/Ordering/Language/Order/Commands, src/Contexts/Ordering/Language/Order/Events · high confidence

The legacy Webpack build configuration, including \webpack.config.js\, \tsconfig.json\, \tslint.json\, and the Dockerfile, has been removed from the \src/Web\ directory. This change eliminates the previous setup for compiling TypeScript/React assets, linting, and containerized builds, indicating a shift away from this specific build pipeline.

src/Web · high confidence

The file previously defining the marketing campaign rule model has been moved to the infrastructure exceptions layer and rewritten to define a new StorageException class. This change removes the previous domain entity (CampaignId, RuleId, Description) and introduces a standard exception type that accepts a message, indicating a shift in how storage-related errors are handled within the application.

src/Infrastructure/Exceptions · high confidence

The application's architecture has shifted from a monolithic ServiceStack presentation layer to a distributed model where each business context (Basket, Catalog, Identity, Ordering, Payment) exposes its own API via new \Presentation.Api\ projects. This change is accompanied by the removal of the legacy \docker-compose.dcproj\ and the addition of dedicated endpoints for MongoDB and Elasticsearch, enabling read-model projections and search capabilities. The solution now targets Visual Studio 17 and updates the Docker Compose configuration to manage these new services, including new \mongodb\ and \elasticdb\ containers, while renaming the web frontend service to \eshop/web\.

(repo-wide) · high confidence

Added comprehensive unit tests for the Catalog and Identity contexts to verify domain behavior. In the Catalog context, tests cover the creation, destruction, and reordering state management for products, as well as the creation and destruction of catalog brands and types. In the Identity context, tests validate user registration, disabling, and identification (including password changes and disabled user restrictions), along with role lifecycle management including creation, destruction, activation, deactivation, and revocation.

src/Contexts/Catalog/Domain/Tests, src/Contexts/Identity/Domain/Tests · high confidence

The application has been upgraded to .NET 6 (net6.0) across all context projects (Basket, Catalog, Identity, Ordering, Payment) and endpoints, replacing the previous netstandard2.0 targets. The frontend has been migrated from a custom Webpack/MobX setup to a React 18 application using Create React App (react-scripts 5.0.1), with the old Webpack configuration and dependencies removed. Backend dependencies have been updated to include NServiceBus 8.0.1, Serilog 2.12.0, and Aggregates.NET 0.18.7.112, while test projects now use xUnit 2.4.2 and FakeItEasy 7.3.1. The old ServiceStack-based presentation layer for Location and Marketing has been removed.

(dependencies) · high confidence

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

• CAI 44 → 38 (-6.1)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 65 → 48 (-17.5)
• Architecture 91 → 91 (+0.3)
• Maturity 51 → 51 (+0.0)
• Readiness 26 → 21 (-4.7)
• Security 63 → 55 (-7.9)
• Accessibility 67 → 67 (+0.0)

• High CVE: Microsoft.NETCore.App 1.0.5
• High CVE: Microsoft.NETCore.App 1.0.5
• LLM evaluation failed
• LLM evaluation failed
• No exposed public API
• dormant codebase — no living knowledge left to concentrate

• CommentedOutCode (src/Endpoints/Elastic/UnitOfWork.cs)
• Critical CVE: [GHSA redacted] (src/Frontend/ClientApp/package-lock.json)
• Critical CVE: [GHSA redacted] (src/Frontend/ClientApp/package-lock.json)
• Critical CVE: [GHSA redacted] (src/Frontend/ClientApp/package-lock.json)
• Critical CVE: [GHSA redacted] (src/Frontend/ClientApp/package-lock.json)
• Critical CVE: [GHSA redacted] (src/Frontend/ClientApp/package-lock.json)
• Critical CVE: [GHSA redacted] (src/Frontend/ClientApp/package-lock.json)
• Critical CVE: [GHSA redacted] (src/Frontend/ClientApp/package-lock.json)
• Documentation: no architecture or design documentation (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (src/Contexts/Basket/Applications/Elastic/Setup.cs)
• Duplicated block (10 lines × 2) (src/Contexts/Ordering/Applications/Elastic/Order/Sales.cs)
• Duplicated block (10 lines × 2) (src/Contexts/Ordering/Presentation/Controllers/BuyerAddressController.cs)
• Duplicated block (10 lines × 2) (src/Infrastructure/Extensions/ArrayExtensions.cs)
• Duplicated block (10 lines × 2) (src/Infrastructure/Extensions/ArrayExtensions.cs)
• Duplicated block (10 lines × 3) (src/Contexts/Basket/Applications/Elastic/Basket/Entities/Item/BasketItemIndex.cs)
• Duplicated block (10 lines × 3) (src/Contexts/Basket/Language/Basket/Entities/Item/Models/Item.cs)
• Duplicated block (10 lines × 3) (src/Contexts/Ordering/Applications/Elastic/Order/BuyerOrders.cs)
• Duplicated block (10 lines × 8) (src/Contexts/Basket/Presentation/Program.cs)
• Duplicated block (11 lines × 2) (src/Contexts/Identity/Applications/Elastic/Role/Handler.cs)
• …and 1056 more

• Unchanged — 68 HTTP endpoints

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

charlessolar/eShopOnContainersDDD 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.