falberthen/EcommerceDDD
38.3
Weak · 8 November 2026
18.4k
lines of production code
C#
with TypeScript
7
measurements over time
What this system is
This system is a containerized, event-driven ecommerce platform built on .NET 10 and Angular 21, structured as a microservices architecture. It manages core business domains including customer accounts, product inventory, order processing, payments, and shipments, utilizing Domain-Driven Design principles with Marten for event sourcing and Wolverine for command handling. The platform provides a centralized API gateway for routing, IdentityServer for authentication and authorization, and SignalR for real-time order status updates, all supported by a comprehensive testing suite and observability infrastructure.
How it got here
2020–2024 — Microservices and SPA modernization
32 changes.
The project underwent a comprehensive infrastructure overhaul, migrating to .NET 10 and Angular 21 while restructuring the codebase into a containerized microservices architecture. This period established the core Domain-Driven Design foundations, replacing custom implementations with Wolverine and Marten, and introduced a new Angular Single Page Application with centralized authentication via IdentityServer.
2025–2026 — Kiota client migration and real-time features
10 changes.
The project migrated its API communication to a strongly-typed Kiota-generated client across both the SPA and backend services, enhancing type safety and resilience. Concurrently, it introduced SignalR-based real-time order status updates and expanded the customer onboarding experience with comprehensive authentication flows. The period also established robust observability via OpenTelemetry and added end-to-end testing coverage using Cypress.
Features
Add environment configuration for distributed tracing and SignalR integration
The Angular SPA now includes environment configuration files that define URLs for the API gateway, the SignalR orders hub, and the Aspire dashboard. This enables the frontend to connect to real-time order updates via SignalR and allows users to access the Aspire observability dashboard directly from the application context.
src/EcommerceDDD.Spa/src/environments · high confidence
Added IdentityServer authentication service
The IdentityServer microservice has been added to the platform, providing centralized authentication and authorization. It is built on .NET 10 and uses Duende IdentityServer with ASP.NET Core Identity, storing user data and operational tokens in a PostgreSQL database. The service supports API versioning (v2), persistent signing key management, and email-based user registration with confirmation. It exposes endpoints for login and token issuance, integrating with the broader application via JWT Bearer authentication and custom claim-based authorization policies.
src/Crosscutting/EcommerceDDD.IdentityServer · high confidence
Added core DDD domain primitives and testing utilities
The Core module now includes foundational Domain-Driven Design types: an abstract AggregateRoot\<TKey\> that manages versioning and uncommitted domain events (with specific handling for Marten rehydration), along with DomainEvent and IntegrationEvent base classes that implement the INotification interface. To support testing, the module also provides dummy implementations for aggregate IDs, aggregate roots, and events in the Testing namespace.
Core · high confidence
Angular SPA introduced with Cypress E2E testing and Docker support
The EcommerceDDD application now includes a new Angular Single Page Application (SPA) located in src/EcommerceDDD.Spa. This addition brings a complete frontend environment, including a Dockerfile for containerized deployment via Nginx, and an end-to-end (E2E) testing suite powered by Cypress that validates core user flows such as login, product selection, cart management, and checkout. The SPA is configured with Angular CLI, Jest for unit testing, and specific TypeScript path mappings for modular code organization.
src/EcommerceDDD.Spa · high confidence
Automated backend client generation and multi-database initialization scripts added
New scripts have been introduced to streamline development setup and service communication. The \db\_init.sql\ script now automatically provisions eight distinct databases (identityserver, products, inventory, customers, quotes, orders, payments, and shipments) to support the microservice architecture. Additionally, \regenerate-clients.sh\ automates the generation of C\# backend service clients for eight specific services (SignalR, IdentityServer, ProductCatalog, InventoryManagement, CustomerManagement, QuoteManagement, PaymentProcessing, and ShipmentProcessing) using Kiota, as well as a unified TypeScript API client for the frontend via the API Gateway.
scripts · high confidence
Automated database migration and initial seed for IdentityServer
The application now automatically applies Entity Framework migrations and seeds initial IdentityServer configuration data (clients, identity resources, API resources, and API scopes) upon startup via the new MigrationManager. This ensures that the database schema is up-to-date and that essential identity configuration entries exist before the application begins handling requests, removing the need for manual database setup for these specific resources.
src/Crosscutting/EcommerceDDD.IdentityServer/Database · high confidence
Initial IdentityServer configuration and email settings
This change introduces the foundational configuration for the IdentityServer authentication service. It adds an \EmailSettings\ class to manage SMTP details and the SPA base URL for email flows. It also defines \IdentityConfiguration\, which sets up the API resources, identity resources, and API scopes (read, write, delete) for the \ecommerceddd-api\. Additionally, it configures two clients: a user client using Resource Owner Password Credentials grant with a 4-hour token lifetime, and a machine-to-machine client using Client Credentials grant with a 1-hour token lifetime.
src/Crosscutting/EcommerceDDD.IdentityServer/Configurations · high confidence
Initial SPA shell with authentication and ecommerce routing
The application now includes a root component structure featuring a navigation menu and a router outlet, along with a configuration that registers core services (such as authentication, notifications, and API clients) and enables animations. The routing setup defines lazy-loaded paths for authentication flows (login, account management, password reset) and protected ecommerce sections (home, products, orders, customer details), all secured by an authentication guard.
src/EcommerceDDD.Spa/src/app · high confidence
Initial domain models and events for core ecommerce services
This change introduces the foundational domain layer for the Customer, Inventory, Order, Payment, Product, Quote, and Shipment services. It defines the core aggregates (such as Order, Payment, Shipment, Quote, InventoryStockUnit, and Customer) along with their strongly-typed identifiers and domain events (e.g., OrderPlaced, PaymentCompleted, StockQuantityDecreased). These models establish the state management and event-driven structure for the backend services, enabling the tracking of customer data, inventory levels, order lifecycles, payment statuses, and shipment progress.
Services · high confidence
Introduce API Gateway with Ocelot routing and Swagger aggregation
The EcommerceDDD.ApiGateway service is introduced to centralize external access to the microservices architecture. It uses Ocelot to route upstream requests (e.g., /customerManagement, /orderProcessing) to their respective downstream services (e.g., ecommerceddd-customer-management) with consistent Bearer token authentication and Quality of Service (QoS) options like timeouts and circuit-breaker durations. The gateway aggregates Swagger documentation from individual services using Koalesce, exposing a unified API definition at /swagger/v2/apigateway.yaml for easier client consumption. It also handles SignalR proxying for real-time updates and is containerized with a Dockerfile targeting .NET 10.
src/Crosscutting/EcommerceDDD.ApiGateway · high confidence
Introduce Customer Management service with registration, profile updates, and event history
A new Customer Management service has been added to the platform, enabling customers to register accounts, update their profile information (name, shipping address, store credit), and view their event history. The service exposes public registration and internal endpoints for retrieving customer details and store credit, backed by a domain model that enforces email uniqueness and data validation. It utilizes Marten for event sourcing and projections to maintain customer details and history, and is containerized with a .NET 10 Dockerfile.
src/Services · high confidence
Introduce SignalR-based real-time order status updates
A new SignalR service has been added to provide real-time order status notifications. The service exposes an OrderStatusHub at the /api/v2/signalr endpoint, allowing authenticated customers to subscribe to updates for their own orders. It is configured with API versioning (v2), Swagger documentation, and health checks, and is containerized via a new Dockerfile for deployment.
src/Crosscutting/EcommerceDDD.SignalR · high confidence
Introduces core DDD domain primitives and CQRS interfaces
The core domain layer now includes foundational building blocks for Domain-Driven Design and CQRS. This adds \Entity\ and \IAggregateRoot\ interfaces that utilize a new \StronglyTypedId\<Guid\>\ wrapper to enforce type safety and improve logging clarity for entity identifiers. A \ValueObject\ base class is provided to support immutable value types with proper equality semantics. Additionally, empty marker interfaces \ICommand\ and \IQuery\<T\>\ are introduced to structure command and query operations within the application.
src/Core/EcommerceDDD.Core/Domain · high confidence
Introduction of domain-specific exception classes
The core library now includes specific exception types for domain logic errors: \DomainException\ for general domain violations (supporting an optional inner exception) and \RecordNotFoundException\ for missing records. These classes provide a structured way to handle and identify specific error conditions within the application's business logic layer.
src/Core/EcommerceDDD.Core/Exceptions · high confidence
New API endpoint to trigger real-time order status broadcasts
A new v2 API endpoint (POST /api/v2/signalr/updateorderstatus) has been added to the SignalR cross-cutting layer, allowing authorized M2M clients to trigger real-time order status updates. The endpoint accepts a request containing the customer ID, order ID, status text, and status code, and uses the new IOrderStatusUpdater service to broadcast the update to the specific customer's SignalR group via the OrderStatusHub.
src/Crosscutting/EcommerceDDD.SignalR/API · high confidence
New Identity Server API endpoints for account management
The Identity Server API now exposes a new AccountsController (v2) that provides endpoints for user login, registration, email confirmation, password reset, and account recovery. This introduces a complete authentication and identity lifecycle for customers, including machine-to-machine registration and secure password management flows.
src/Crosscutting/EcommerceDDD.IdentityServer/API · high confidence
New SPA shell and shared UI components
The application now includes a new Angular SPA entry point with a navigation menu, routing configuration, and shared UI components. Users will see a main layout with a nav menu displaying links to Orders, Products, and Profile, along with a currency selector and logout option. The SPA also introduces a confirmation dialog modal, a loader skeleton for loading states, and a stored events viewer that displays a timeline of event history with formatted fields. These components are registered in the app configuration and routed through the new app.routes.ts file.
src/EcommerceDDD.Spa/src/app/shared · high confidence
New customer account creation and login pages with currency selection and event history
The application now includes dedicated pages for creating a new customer account and logging in, featuring form validation and account creation workflows. A currency dropdown component allows users to switch between USD, CAD, and EUR, with the selection persisted in local storage. Additionally, the cart, customer details, and orders views now support viewing stored event history for quotes, customer profiles, and orders respectively, and the orders view includes a 'Confirm Delivery' action for shipped orders.
src/EcommerceDDD.Spa/src/app/features/ecommerce · high confidence
New customer registration and authentication flows
The application now includes a complete customer onboarding and authentication experience. Users can create new accounts via the Customer Account page, which collects email, name, shipping address, and password details. The Login page has been enhanced to support email confirmation workflows, allowing users to resend confirmation emails if their account is not yet verified. Additionally, a Forgot Password feature enables users to request a password reset link, and a Reset Password page allows them to set a new password using the token from that link. An Email Confirmation page provides feedback on the status of the confirmation process.
src/EcommerceDDD.Spa/src/app/features/authentication · high confidence
New identity infrastructure with role-based access and customer ownership checks
The Identity layer now includes a complete set of new components to handle authentication and authorization. This introduces JWT-based authentication with support for SignalR query-string tokens, a centralized policy builder defining CanRead, CanWrite, and CanDelete scopes, and a dedicated TokenRequester that caches application tokens to reduce IdentityServer load. Crucially, it adds a CustomerOwnershipExtensions helper to enforce Broken Object Level Authorization (BOLA) protections by ensuring resources belong to the current customer, alongside interfaces and implementations for retrieving user info and tokens.
src/Core/EcommerceDDD.Core.Infrastructure/Identity · high confidence
New user registration result model
A new \UserRegistration\ record and \RegistrationStatus\ enum have been added to the IdentityServer models to represent the outcome of user registration attempts. This model allows the system to explicitly distinguish between successful registration, cases where the email is already taken, and rejected registrations with specific error details, providing a structured way to handle registration feedback.
Crosscutting · high confidence
OpenTelemetry observability and order ID correlation
The infrastructure layer now includes OpenTelemetry support, registering ASP.NET Core, HTTP client, and Npgsql instrumentation along with OTLP exporters for traces and metrics. A custom log processor automatically attaches the active order ID to log records, and a Wolverine chain policy ensures that command and event handlers carrying an OrderId are tagged with 'order.id' for consistent distributed tracing.
src/Core/EcommerceDDD.Core.Infrastructure/OpenTelemetry · high confidence
Resilient customer registration with email confirmation and password reset
The Identity Server now supports a complete customer onboarding flow, including user registration, email address confirmation, and password recovery. A new IdentityManager service orchestrates these operations, ensuring that registration is idempotent and handles race conditions, while the SmtpEmailSender delivers the necessary confirmation and reset links. Additionally, a CustomProfileService has been introduced to correctly issue user claims, including email and role information, within authentication tokens.
src/Crosscutting/EcommerceDDD.IdentityServer/Services · high confidence
Architecture
Comprehensive infrastructure and development environment overhaul
The repository has been restructured to support a modern, containerized development workflow. A new Docker Compose stack is introduced, defining infrastructure services (PostgreSQL 18, Kafka 7.8.0, Kafka UI, pgAdmin, and the Aspire Dashboard) and orchestrating the application's microservices (IdentityServer, API Gateway, SignalR, and domain services like Order and Payment Processing) with standardized health checks and dependency management. The solution file has been significantly refactored to reflect a new project topology, separating Core, Crosscutting, and Services layers, and adding dedicated test projects for each service. Additionally, developer tooling has been updated with a new .editorconfig for consistent C\# styling, a .nvmrc pinning Node.js to 20.20.0, and a new Docker Compose 'tools' profile that automates Kiota client regeneration using .NET SDK 10.0.
(repo-wide) · high confidence
Behavioural changes
Adopts Wolverine for CQRS and event bus infrastructure
The core module now relies on the Wolverine framework for its Command Query Responsibility Segregation (CQRS) and event bus capabilities, replacing the previous custom implementation. This shift is evidenced by the introduction of global usings for 'JasperFx' and 'EcommerceDDD.Core.CQRS', indicating a move to a standardized library for handling commands, queries, and asynchronous messaging within the application core.
src/Core/EcommerceDDD.Core · high confidence
Adopts Wolverine for messaging and introduces Newtonsoft serialization for durable messages
The infrastructure layer has replaced its previous custom CQRS and Kafka-based messaging implementation with Wolverine. This change introduces a new Newtonsoft-based message serializer (NewtonsoftMessageSerializer) specifically designed to handle the serialization of immutable domain value objects and command records for durable inbox and dead-letter scenarios, ensuring reliable message persistence and recovery within the new Wolverine transport.
src/Core/EcommerceDDD.Core.Infrastructure · high confidence
Generated Kiota-based API client for the SPA
The SPA now uses a Microsoft Kiota-generated TypeScript SDK to communicate with the backend, replacing the previous manual HTTP client implementation. This new client provides a strongly-typed, fluent API for all backend services, including customer management (registration, details, history), inventory management (stock tracking), order processing, product catalog, and quote management. The change introduces a new \ApiClient\ entry point and associated request builders that handle serialization, deserialization, and error mapping for the API v2 endpoints, ensuring type safety and consistent request construction across the application.
src/EcommerceDDD.Spa/src/app/clients · high confidence
Identity and IdentityServer database schema updates
The IdentityServer database migrations have been updated to support the initial setup of ASP.NET Core Identity tables (users, roles, claims, logins, tokens) and Duende IdentityServer configuration entities (API resources, scopes, clients, identity providers). Additionally, a new migration adds a DataProtectionKeys table to persist encryption keys for ASP.NET Core data protection, and the configuration database schema has been upgraded to align with Duende IdentityServer version 8.
src/Crosscutting/EcommerceDDD.IdentityServer/Migrations · high confidence
Introduce Kiota-based API clients and centralized error handling
The SPA core now uses Microsoft Kiota to generate typed API clients for all backend services (auth, customer, order, inventory, product, quote), replacing previous HTTP implementations. A new \KiotaClientService\ manages authenticated and anonymous clients, automatically attaching bearer tokens and logging out the user on 401 responses. A robust \ApiErrorParserService\ and \ApiErrorHandlerService\ now parse various error formats (including ASP.NET ValidationProblemDetails and Kiota-specific shapes) and display user-friendly notifications, while a new \authGuard\ and \AuthService\ handle session state and email confirmation flows.
src/EcommerceDDD.Spa/src/app/core · high confidence
Introduce Kiota-based backend service clients with resilience and configuration
The service client layer has been refactored to use Kiota-generated HTTP clients for all backend services (Identity, Customer Management, Inventory, Product Catalog, Quote, Payment, Shipment, and SignalR). These clients are registered via extension methods that apply Polly-based resilience policies (retry with exponential backoff and circuit breaking) and automatic Bearer token authentication. Configuration is centralized in a new ServiceClientsOptions class, mapping to the 'Services' configuration section, and the clients are explicitly registered for service location to support Wolverine's code generation requirements.
src/Crosscutting/EcommerceDDD.ServiceClients · high confidence
Introduce Marten-based event store with Wolverine outbox integration
The infrastructure layer now uses Marten as the event store, replacing previous custom CQRS/Kafka/outbox implementations. This change introduces a new \MartenRepository\ that handles event appending and fetching with optimistic concurrency, while integrating with Wolverine's outbox to ensure durable delivery of integration events alongside aggregate state changes. Configuration is managed via \MartenConfigExtension\, supporting separate read/write schemas and Newtonsoft serialization, and a new \IQuerySessionWrapper\ is provided to facilitate testing by abstracting Marten's query session.
src/Core/EcommerceDDD.Core.Infrastructure/Marten · high confidence
Introduce specific error types for the Result pattern
The validation layer now includes dedicated error classes (ForbiddenError, RecordNotFoundError, ValidationError) that inherit from FluentResults.Error. This change supports the broader migration from ApiResponse wrappers to a Result pattern, enabling more granular handling of validation failures, forbidden access, and missing records within the application's core logic.
src/Core/EcommerceDDD.Core/Validation · high confidence
Migrate message handling infrastructure to Wolverine with enhanced resilience
The application's core infrastructure now uses Wolverine for command, query, and event dispatch, replacing the previous custom CQRS, Kafka, and Outbox implementations. This change introduces a unified retry strategy where transient failures (such as HTTP request errors or concurrency issues) are retried with exponential backoff, while domain rule violations are moved directly to an error queue. Additionally, a new policy ensures that failed business results are handled explicitly rather than cascading as messages, and OpenTelemetry observability is configured to tag spans with order IDs for better traceability.
src/Core/EcommerceDDD.Core.Infrastructure/Extensions · high confidence
New event store repository interface with Wolverine outbox integration
The persistence layer now exposes an IEventStoreRepository interface that manages aggregate state by appending uncommitted events and committing them in a single transaction. This interface is tightly integrated with Wolverine's durable outbox, ensuring that domain events and outgoing messages are persisted atomically—either both are committed or neither is, and messages are not dispatched until the commit succeeds. It also provides a method to fetch aggregates for writing, supporting optimistic concurrency control via version tracking.
src/Core/EcommerceDDD.Core/Persistence · high confidence
Standardized API error responses and versioning infrastructure
The WebApi infrastructure now provides a consistent error-handling model and API versioning support. Controllers inherit from a new CustomControllerBase that automatically maps CQRS command/query results to standardized HTTP ProblemDetails responses, handling specific cases like validation errors (422), forbidden access (403), and not found (404). A GlobalExceptionHandler catches unhandled exceptions, mapping domain exceptions to 422 and others to 500, while including trace IDs in the response. API versioning is configured to default to V2, read versions from URL segments, and report available versions. Additionally, Swagger UI is configured to document the API with Bearer JWT authentication requirements, and a health check endpoint is exposed at /health.
src/Core/EcommerceDDD.Core.Infrastructure/WebApi · high confidence
Test coverage
Added Cypress-based end-to-end tests for the SPA; Added global usings for test infrastructure; Added test coverage for infrastructure components; Added testing infrastructure and architecture validation rules; Added unit tests for AggregateRoot and StronglyTypedId domain primitives; Added unit tests for CQRS command and query handlers.
Dependencies
Upgrade to .NET 10 and Angular 21 with centralized dependency management
The project has been upgraded to target .NET 10.0 (previously .NET Core 3.1) and Angular 21.1.3 (previously Angular 19.2). To streamline maintenance, the solution now uses Central Package Management via \Directory.Packages.props\, which defines versions for key libraries including Duende IdentityServer 8.0.6, WolverineFx 6.30.3, Marten 9.30.0, and Ocelot 25.0.0. This change also introduces Kiota-based HTTP client generation and consolidates the infrastructure layer to support these modernized dependencies.
(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 37 → 38 (+1.5)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 84 → 84 (+0.2)
- Architecture 84 → 81 (-3.5)
- Maturity 54 → 70 (+16.5)
- Readiness 26 → 26 (-0.0)
- Security 48 → 48 (-0.5)
- Domain Modelling 73 → 73 (+0.0)
- Event-Driven 100 (new)
- Event Sourcing 71 → 77 (+5.9)
- Accessibility 31 → 31 (+0.2)
- Performance 100 → 100 (+0.0)
Resolved (71)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.CustomerManagement/Domain/Events/CustomerRegistered.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.CustomerManagement/Domain/Events/CustomerRegistered.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.CustomerManagement/Domain/Events/CustomerUpdated.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.CustomerManagement/Domain/Events/CustomerUpdated.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.InventoryManagement/Domain/Events/StockQuantityDecreased.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.InventoryManagement/Domain/Events/StockQuantityDecreased.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.InventoryManagement/Domain/Events/StockQuantityIncreased.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.InventoryManagement/Domain/Events/StockQuantityIncreased.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.InventoryManagement/Domain/Events/UnitEnteredInStock.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.InventoryManagement/Domain/Events/UnitEnteredInStock.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderCanceled.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderCanceled.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderDelivered.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderDelivered.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderPaid.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderPaid.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderPlaced.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderPlaced.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderProcessed.cs)
- Cross-context type DomainEvent (Core → Services) (src/Services/EcommerceDDD.OrderProcessing/Domain/Events/OrderProcessed.cs)
- …and 51 more
New (22)
- High CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- High CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- High CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- High CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- High CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- High CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- High CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- Low CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- Medium CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- Medium CVE: [GHSA redacted] (src/EcommerceDDD.Spa/package-lock.json)
- Projects may be oversized for their cohesion (src/Crosscutting/EcommerceDDD.ServiceClients/EcommerceDDD.ServiceClients.csproj)
- doc comments repeat the names (src/Crosscutting/EcommerceDDD.ServiceClients/Extensions/KiotaClientExtensions.cs)
- doc comments repeat the names (src/EcommerceDDD.Spa/src/app/clients/api/index.ts)
- doc comments repeat the names (src/Services/EcommerceDDD.CustomerManagement/API/Controllers/CustomersInternalController.cs)
- doc comments repeat the names (src/Services/EcommerceDDD.InventoryManagement/API/Controllers/InventoryController.cs)
- doc comments repeat the names (src/Services/EcommerceDDD.OrderProcessing/API/Controllers/OrdersController.cs)
- doc comments repeat the names (src/Services/EcommerceDDD.ProductCatalog/Infrastructure/Extensions/DataSeedExtension.cs)
- doc comments repeat the names (src/Services/EcommerceDDD.QuoteManagement/API/Controllers/QuotesController.cs)
- redundant comment (src/Core/EcommerceDDD.Core.Infrastructure.Tests/OpenTelemetry/MeterRegistrationTests.cs)
- redundant comment (src/Core/EcommerceDDD.Core.Infrastructure/Marten/MartenConfigExtension.cs)
- …and 2 more
API surface
- Unchanged — 28 HTTP endpoints
Architecture
- Unchanged — 12 containers · 3 contexts · 3 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
falberthen/EcommerceDDD 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 8 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 4d80939f649c1072a58086666bb670d40cbe29f3 — the exact code this score is about.
- Scored under rubric-2026.11.2 — 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.3+preprod-45ab2cab63de.