mahedee/code-sample02

This repository is a comprehensive collection of .NET-based microservice and architectural pattern demonstrations, focusing on backend API development and frontend integration. It provides concrete implementations of common enterprise scenarios, including JWT authentication, optimistic concurrency control, event sourcing, and saga choreography. The codebase also showcases infrastructure concerns such as API gateways, health checks, and containerized deployments, serving as a practical reference for building scalable, distributed systems.

23 changes.

This period focused on expanding the codebase with diverse microservice implementations, including customer, ordering, and catalog APIs, alongside a new React frontend. Significant work also went into implementing JWT-based authentication across multiple services and introducing an Ocelot-based API gateway to route traffic and expose Swagger UI.

17 changes.

This period focused on expanding the codebase with diverse architectural patterns, particularly microservices, API gateways, and micro-frontends. Significant effort was also directed towards implementing optimistic concurrency control mechanisms, including ETags, row versions, and hypermedia-based strategies across various demo projects.

14 changes.

This period focused on implementing various design patterns, such as Facade, Factory, and OCP, alongside the development of multiple microservices architectures for e-commerce and HRM systems. The work also included adding middleware for logging, Azure Functions for cache refresh, and APIs for document management and reporting.

A new Azure Functions app has been introduced to periodically fetch exchange rate data from an external API and store it in a Redis cache with a 5-minute expiration. The implementation includes a timer-triggered function that retrieves fresh data, updates the cache, and logs the results, supported by the necessary project structure, configuration files, and deployment profiles.

CacheRefreshFunction · high confidence

The sd-docker-demo area now includes a complete microservices stack for local development and containerized deployment. This includes a BFF (Backend For Frontend) gateway built with Ocelot and Swagger integration, alongside three location API services (LocationA, LocationB, LocationC) that register with a Eureka service discovery server. The setup is orchestrated via docker-compose files that link all services on a shared backend network, with each API container exposing its Swagger UI for testing.

sd-docker-demo · high confidence

Introduced a new .NET Core API for managing products, including a ProductController with endpoints for listing, retrieving, creating, and updating products. The implementation uses an in-memory database via EcommerceDbContext and a ProductRepository. Additionally, comprehensive metrics tracking is enabled through App.Metrics, exposing Prometheus-compatible endpoints (/metrics, /metrics-text, /ping) for monitoring API performance, error rates, and business KPIs such as product views and average price.

grafana-dotnet-core · high confidence

The Ocelot API Gateway is introduced to route requests to downstream microservices (BFF.Web, Catalog.API, Location.API, and Ordering.API) and expose their Swagger documentation via a unified Swagger UI. The gateway configuration includes route definitions for each service, with specific upstream paths (/catalog, /location, /ordering) mapping to their respective downstream APIs. The Swagger UI is configured to display the OpenAPI specifications for all integrated services, allowing users to explore and test the APIs through a single interface.

ocelot-swagger · high confidence

The application now supports event sourcing for catalog items. This includes domain models, commands, handlers, and queries for creating, updating, and deleting catalog items. The infrastructure layer provides an \IAggregateRepository\ to persist and read events from an EventStore database, while a SQL database is also used to store the current state of catalog items. A custom \PrivateSetterContractResolver\ is introduced to handle JSON serialization of private setters during event rehydration.

EventSourcing · high confidence

The health-check area now includes multiple ASP.NET Core API services (Admin, Customer, Location, Product, and WebStatus) that expose health check endpoints. The WebStatus service acts as a central dashboard, configured to monitor the health of the other services via their respective /hc, /liveness, /customersql, and /customerdbcontext endpoints. This introduces a new capability for users to monitor the status of various backend services and database connections through a unified UI.

health-check · high confidence

The MicroservicesDemo area now includes a complete microservices architecture for an e-commerce demo. This includes an OrderService and a ProductService, each with their own Dockerfiles, controllers, models, and data contexts. The services communicate via a shared EventBus (Kafka-based) that publishes and subscribes to events like OrderCreated, ProductCreated, and ProductUpdated. The demo also includes a docker-compose.yml to orchestrate SQL Server, Zookeeper, Kafka, and the two services, along with a solution file (.slnx) to organize the project structure.

MicroservicesDemo · high confidence

The PrivateRegistryDemo location now includes a complete ASP.NET Core Web API project, featuring a WeatherForecast controller, a corresponding data model, and configuration files (appsettings, launchSettings). The addition of a Dockerfile and .dockerignore enables containerized builds and debugging via Visual Studio, while the solution file and HTTP test file support standard .NET development workflows.

PrivateRegistryDemo · high confidence

The Accounting.API project has been introduced, providing a RESTful API for managing transaction details. The \TransactionDetailsController\ implements idempotency for POST requests by generating a SHA-256 hash of the transaction data and checking a Redis cache before processing. If the hash already exists in the cache, the existing transaction is returned; otherwise, the transaction is saved to the SQL Server database and cached. The API includes endpoints for creating, reading, updating, and deleting transaction records, supported by an Entity Framework Core context and an initial database migration.

IdempotentDemo · high confidence

Introduced the Catalog and Ordering microservices to support a saga choreography pattern. The Catalog API provides a RESTful interface to manage catalog items and listens for order creation events to update stock levels, publishing a success or failure response. The Ordering API exposes an endpoint to submit new orders and listens for catalog responses to handle order failures by removing the corresponding order items. Both services are configured with SQLite databases, Swagger documentation, and RabbitMQ integration for inter-service communication.

saga-choreography · high confidence

The ConcurrencyHandling.API project has been added, introducing a new RESTful service for managing 'Account' resources. The implementation includes a standard CRUD controller (AccountsController) and an Entity Framework Core context (ApplicationDbContext) configured with a 'RowVersion' concurrency token. This configuration enables optimistic concurrency control, ensuring that updates to accounts are rejected if the underlying database row has been modified by another transaction since it was last read. The change also includes the necessary database migration files and model definitions to support this concurrency mechanism.

ConcurrencyDBToken · high confidence

Introduced a new ASP.NET Core API project, ConcurrencyHandling.API, that exposes a RESTful interface for managing Employee records. The implementation uses a RowVersion (Guid) field to enforce optimistic concurrency; the API returns hypermedia links (rel, href, method) in GET responses and requires the client to pass the current RowVersion as a query parameter for PUT and DELETE operations. If the provided version does not match the current database state, the server returns a 409 Conflict, preventing lost updates. The project includes the Employee model, an Entity Framework Core DbContext, and the initial database migration script.

ConcurrencyHyperMedia · high confidence

The Customer API service has been introduced, providing a new RESTful interface for managing customer records. Users can now perform Create, Read, Update, and Delete operations via HTTP endpoints (GET, POST, PUT, DELETE) exposed by the CustomerController. The implementation leverages a Dapper-based repository layer to interact with the database, supporting queries by ID, email, and general retrieval, with dependency injection configured in the application startup.

DapperDemo · high confidence

Introduced a new 'Ordering' service within the CleanArchitectureDemo, implementing a clean architecture with separate layers for API, Application, Core, and Infrastructure. This includes a CustomerController exposing REST endpoints for creating, editing, and deleting customers, alongside MediatR-based commands and queries for customer management. The infrastructure layer utilizes Entity Framework Core for command operations and Dapper for query operations against a SQLite database, with an initial migration script provided to create the 'Customers' table.

CleanArchitectureDemo · high confidence

Introduced the ECommerceFacade project, which implements the Facade design pattern to simplify the e-commerce workflow. The new code provides an OrderProcessingFacade that coordinates InventorySystem, PaymentGateway, ShippingSystem, and NotificationService to handle the complete order placement process, including stock checks, payment processing, and order confirmation.

ECommerceFacade · high confidence

Introduced a new Facade pattern implementation that provides a simplified interface to a set of subsystems (SubsystemA through SubsystemD). The code includes four distinct subsystem classes, a Facade class that coordinates them, and a Program entry point demonstrating how to use the facade to perform two different composite operations.

FacadePattern · high confidence

The jenkins-demo/HRM directory now contains a complete .NET API project (HRM.API) that exposes REST endpoints for managing employees (create, read, update, delete). The implementation uses an in-memory database (HRMContext) and includes a SeedDataGenerator that populates the database with initial employee records on startup. The API is configured with dependency injection for its repository and service layers, and Swagger is enabled for API documentation.

jenkins-demo · high confidence

A new demo project was added that demonstrates implementing the IValidatableObject interface for an Employee class. The Employee class includes custom validation logic in its Validate method to check for required fields (Id and Name), and the Program.cs entry point uses Validator.TryValidateObject to validate both a valid and an invalid Employee instance, illustrating how to perform manual validation in .NET.

IValidatebleObject · high confidence

The application now supports JWT (JSON Web Token) authentication. Users can obtain a JWT token by sending a POST request to the new /api/Auth endpoint with their username and password. Subsequent requests to protected endpoints, such as the Weather Forecast API, must include this token in the Authorization header to be accepted. The configuration for this authentication scheme and the associated model classes have also been added.

Archive · high confidence

A new ASP.NET Core Web API for product management (Catalog.API) is introduced, featuring a ProductsController with full CRUD operations backed by Entity Framework Core migrations and a SQL Server database context. The change also includes a Dockerfile for containerizing the API, a Kubernetes pod deployment manifest, and configuration files (appsettings, launch settings). Additionally, Kubernetes dashboard installation and admin user setup manifests are added to the demo.

kubernetes-demo · high confidence

Introduced two C\# implementations of the Observer design pattern. The first is a generic solution demonstrating a subject and observer interface with attach/detach/notify mechanics. The second is a domain-specific example for stock notifications, where a 'Stock' subject notifies 'Trader' observers about price changes. Both include class diagrams and console-based demonstration code.

ObserverPattern · high confidence

The ecommerce.client directory now includes a complete React application for the frontend. This adds token-based authentication flows (Login, Logout, Registration) and a comprehensive set of user and role management interfaces (Create, Edit, Delete for Users and Roles). The application uses a SessionManager to store and retrieve authentication tokens from sessionStorage, and routes are protected to redirect unauthenticated users to the login page.

token-based-auth-core-react/ecommerce.client · high confidence

The react.client directory is now a Git submodule pointing to commit 7138f9a64d3d08262808bd097f48b27d2919afb9, linking the React client code as a separate repository within the project.

react-bootstrap-template · high confidence

A new CryptoEngine library was added, providing a static method to generate SHA-256 hashes of plain text strings. A corresponding test application (CryptoTest) was also added to demonstrate the hashing functionality by outputting both the original text and its resulting hash value.

dotnet-core-nuget-github · high confidence

A new C\# solution and project have been added to demonstrate the singleton design pattern. The implementation features a thread-safe, sealed \SingletonEmployeeService\ class that manages a list of \Employee\ objects, providing a global access point via a static \GetInstance\ method and methods to add and retrieve employee data.

singleton-pattern · high confidence

Introduced new shell and PowerShell scripts (commit-and-push-all.sh and commit-and-push-all.ps1) that automatically stage all changes, commit them with a timestamped message, and push to the current branch. Additionally, the .gitignore file was updated to exclude the node\_modules directory from version control.

(repo-wide) · high confidence

A new Java application has been added that demonstrates various binary tree traversal algorithms. The project includes a core \BinaryTree\ class supporting preorder, inorder, postorder, and level-order traversals. Practical applications are also provided, including an AST processor for code generation and pretty-printing, a database index range query simulator, a file system directory traversal utility, and a scene graph renderer for game engines.

binary-tree-traversal-app · high confidence

Two new ASP.NET Core applications were added to the codebase. The ConcurrencyRawSQL project provides a raw SQL-based API for managing products, including endpoints for creating, reading, updating, and deleting product records with concurrency control via row versions. The EFBulkBatch project demonstrates high-performance data operations using Entity Framework Core, offering bulk insert, update, and delete capabilities for customer and employee entities. Both applications include necessary configuration files, database contexts, and service layers to support their respective data access strategies.

ConcurrencyRawSQL, EFBulkBatch · high confidence

The application layer now includes new command and query handlers to support full customer lifecycle operations. Command handlers allow creating, editing, and deleting customers, while query handlers enable retrieving all customers, fetching a customer by ID, or searching by email. These handlers implement the MediatR pattern to process requests and interact with the underlying repositories.

CleanArchitectureDemo/Ecommerce/Services/Ordering/Ordering.Application/Handlers/CommandHandler, CleanArchitectureDemo/Ecommerce/Services/Ordering/Ordering.Application/Handlers/QueryHandlers · high confidence

Added Kubernetes manifests and configuration for an Elasticsearch, Fluentd, and Kibana (EFK) logging stack, including a Fluentd handler for Istio log entries. Additionally, added deployment and service definitions for the BFF (Back-For-Front) gateway, as well as the Catalog, Location, and Ordering API microservices, each with their respective Dockerfiles, controllers, and K8s deployment files.

service-mesh · high confidence

A new \RequestResponseLoggingMiddleware\ has been introduced to the application, wrapping the HTTP request pipeline to log incoming request details and outgoing response status codes along with the elapsed time. This middleware is registered in \Program.cs\ and is active in the development environment, providing visibility into request processing times and response states for the \/weatherforecast\ endpoint.

MiddlewareExample · high confidence

The HRM API now exposes a new EmployeesController that provides RESTful endpoints for creating, reading, updating, and deleting employee records. This includes a seed data generator that pre-populates the in-memory database with initial employee records, and a Dockerfile for containerized deployment. Additionally, a default WeatherForecast endpoint is included for development and testing.

hrm · high confidence

The HRM API introduces a new employee management capability, exposing RESTful endpoints to create, read, update, and delete employee records. The service is built on ASP.NET Core 8.0, utilizing Entity Framework Core with a SQL Server backend (configured via appsettings.json) to persist data in an 'Employees' table. The project includes a multi-stage Dockerfile for containerization and Kubernetes deployment manifests (pod and service) for AKS, exposing the application on ports 8080 and 8081.

aks-hrm · high confidence

The api-gateway-ocelot area now includes a complete Ocelot-based API gateway (BFF.Web) that routes requests to downstream services. The gateway is configured to proxy to a Location service (GET /Countries/GetAll with 30-second file caching), a Catalog service (GET/POST/PUT/DELETE /Products with rate limiting of 1 request per 5 seconds), and an Ordering service (catch-all routing). Additionally, standalone ASP.NET Core Web API projects (Catalog.API, Location.API, Ordering.API) are added with their own controllers, models, and in-memory database contexts, providing the backend endpoints that the gateway routes to.

api-gateway-ocelot · high confidence

The saga-choreography-v02 area now contains the full implementation for the Ecommerce Saga, including the Catalog.API, Order.API, and Payment.API services. Each service exposes REST endpoints for managing resources (e.g., products, orders, and payment transactions) and integrates with RabbitMQ to publish and subscribe to domain events. Background hosted services (e.g., OrderCreatedListener, InventoryResponseListener) process these events to coordinate the saga flow, such as reserving inventory, confirming payments, and handling compensating transactions for failures.

saga-choreography-v02 · high confidence

The repository now includes a complete micro-frontend implementation. The \master-frontend\ directory provides a React shell application that dynamically loads and unmounts micro-frontends. The \header-frontend\ and \customer-frontend\ directories contain the respective React applications, each bootstrapped with Create React App and configured for independent development. The \customer-backend\ directory introduces a .NET 6 Web API (\Customers.API\) that exposes a RESTful interface for customer data, utilizing an in-memory database and a seed generator for initial data. This change establishes the foundational structure for a micro-frontend system, enabling the master shell to compose the header and customer micro-frontends.

(repo-wide) · high confidence

The AuditLog API is introduced, providing endpoints to manage customer records (create, read, update, delete) and retrieve audit change logs. The implementation uses Entity Framework Core with SQL Server, featuring custom \CustomAuditEntry\ models and a database migration that creates \Customers\, \Products\, and audit tracking tables. Users can now perform standard CRUD operations on customers, with all changes automatically logged to the \AuditEntry\ and \AuditEntryProperty\ tables via the \Z.EntityFramework.Plus\ library. Additionally, a reporting endpoint allows querying the change log for specific entities.

AuditLogEFPlus · high confidence

The ECommerce API is introduced, providing RESTful endpoints for managing Customers and Products, including CRUD operations and search capabilities. The backend uses an in-memory database with seed data for initial testing. On the frontend, a React application is added, featuring components for listing, creating, and editing products and customers, integrated with Redux for state management and React Router for navigation.

react-redux-toolkit, react-redux-toolkit/redux-app · high confidence

Introduced a new .NET-based API gateway (BFF.Web) configured with Ocelot and Swagger integration, enabling request routing and quality-of-service (QoS) policies such as circuit breaking and timeouts. Added a corresponding Catalog.API service that exposes catalog item endpoints and seeds initial data. The gateway routes /catalog requests to the Catalog API, enforcing QoS options including an exception threshold of 2, a 5-second circuit-breaker duration, and a 3-second timeout.

api-gateway-ocelot-qos · high confidence

The sd-demo area now includes a complete .NET-based microservices architecture. The BFF.Web project acts as an Ocelot API gateway, routing requests to Customer.API, Location.API, and Product.API, each of which is a standalone ASP.NET Core Web API. All services are configured to register with a Eureka service discovery server, and the gateway integrates Swagger UI to aggregate and display the OpenAPI documentation for each backend service.

sd-demo · high confidence

The Clean Architecture project template now includes a complete, runnable solution structure. The API layer provides a HomesController, global exception handling via ApiExceptionFilterAttribute, and Swagger/OpenAPI configuration for OAuth2. The application layer introduces MediatR pipeline behaviors for authorization, validation, and unhandled exceptions, alongside custom exception types and a validation pipeline. The infrastructure layer adds Entity Framework Core and Dapper repositories, a Unit of Work pattern, and configuration classes for database connections and Identity Server. The template also registers these services via DI, enabling a structured approach to building .NET applications.

CleanArchitectureTemplate · high confidence

The asp-azure-key-vault area now contains a complete ASP.NET Core Web API for an e-commerce system. The application integrates with Azure Key Vault to load secrets such as the SQL connection string and JWT signing key. It provides endpoints for user registration and login, product catalog management, and order processing with stock validation. Additionally, a development-only ConfigController exposes Key Vault secret keys for verification, and the application seeds a default admin user on startup.

asp-azure-key-vault · high confidence

The multi-env-app now includes a new HRM (Human Resources Management) API. This adds RESTful endpoints for managing departments and employees, including creating, reading, updating, and deleting records. The API exposes controllers for /api/departments and /api/employees, supported by DTOs for data transfer, a database context (HrmDbContext) with initial migrations, and seed data for departments and employees. A default WeatherForecast controller is also present.

multi-env-app · high confidence

The AuditLog.API service now includes a complete audit trail implementation that records entity state changes (Insert, Update, Delete) into a SQL database, exposing a reporting endpoint to query these logs. Additionally, the ConcurrencyHandling.API service introduces optimistic concurrency control for Booking entities using a versioning token to prevent simultaneous updates.

AuditLogRawSQL, ConcurrencyAppToken · high confidence

The ASP.NET Core application now includes a new DocumentsController that exposes RESTful endpoints for uploading, downloading, listing, and deleting documents. The implementation integrates with Azure Blob Storage via a dedicated BlobStorageService, while document metadata is persisted in a SQL Server database using Entity Framework Core, with an initial migration creating the Documents table.

dms-azure-blob-aspnet · high confidence

Added a new ExportReportAPI that exposes endpoints to retrieve employee data and export it as Excel, PDF, or Word documents. The API includes a RESTful controller for standard CRUD operations on employees and dedicated export endpoints that generate formatted reports with company branding, headers, and footers. The implementation uses an in-memory database for initial data seeding and registers template services for each export format.

export-report-api · high confidence

Added a new console application that calculates the area of various geometric shapes (Rectangle, Triangle, Circle, and Pentagon) using an abstract base class and polymorphism. The implementation allows new shapes to be added without modifying existing code, adhering to the Open-Close Principle. The application iterates through a list of shapes, calculates their areas, and displays the results.

ocp · high confidence

The application now supports a multi-tenant model, introducing separate authentication flows for Admin and Tenant users. The AuthController provides distinct login endpoints for each, generating JWT tokens that include tenant-specific claims. A new TenantController allows Super Admins to create, read, update, and delete tenants, each with its own database connection. The system automatically provisions and migrates tenant databases upon creation. Additionally, a global ExceptionHandlingMiddleware standardizes error responses across all controllers.

MultiTenant · high confidence

The Ordering.API now supports JWT-based authentication and authorization. A new AuthController exposes a login endpoint that issues JWTs, while controllers for Customers, Users, and Roles are protected by JWT Bearer tokens and role-based access control (e.g., Admin, Management). The application's startup (Program.cs) configures JWT validation, registers MediatR handlers, and enables CORS and Swagger with Bearer security definitions. Application-layer commands and queries for user, role, and customer management are implemented using the Mediator pattern, supported by new DTOs, exception classes, and a TokenGenerator service.

token-based-auth-ng · high confidence

The ECommerce API now supports JWT-based authentication and authorization. Users can log in to receive a JWT token, which is then used to access protected endpoints for managing customers, roles, and users. The API enforces role-based access control, requiring 'Admin' or 'Management' roles for most user and role management operations. Additionally, a CORS policy is configured to allow cross-origin requests.

token-based-auth-core-react/ECommerce · high confidence

The ECommerce API now supports JWT-based authentication and comprehensive user and role management. Users can log in to receive a JWT token, which is then used to access protected endpoints for creating, reading, updating, and deleting customers, users, and roles. The implementation includes new controllers for authentication, customer, user, and role management, along with the necessary MediatR commands and queries to handle the business logic. Additionally, the application is configured to use JWT Bearer authentication, allowing for secure access to the various API endpoints.

token-based-auth-core · high confidence

Added a new \AccountFactory\ that centralizes the creation of \IAccount\ implementations (Savings, Checking, and Business Checking). Users can now instantiate specific account types via an enum or string, with the factory handling the mapping to concrete classes. This introduces a new way to create and manage bank accounts in the application.

factory-pattern · high confidence

The ProductsController now enforces optimistic concurrency using ETags. When updating or deleting a product, the API validates the If-Match header against the current RecordVersion; if the versions do not match, the request fails with a 412 Precondition Failed status code. GET requests include the current RecordVersion in the ETag header, allowing clients to detect concurrent modifications.

ConcurrencyEtags · high confidence

Added .csproj and pom.xml files for a wide range of demo applications, including Clean Architecture templates, event sourcing, microservices, API gateways, and health checks. These project files define dependencies such as Microsoft.EntityFrameworkCore, Swashbuckle.AspNetCore, and MediatR, and specify target frameworks ranging from net5.0 to net10.0, enabling the build and execution of these specific demo projects.

(dependencies) · high confidence

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

• CAI 31 → 44 (+13.3)
• Rubric changed (rubric-2026.08.18 → rubric-2026.08.19) — scores are not directly comparable.

• Code Health 48 (new)
• Architecture 82 (new)
• Maturity 21 → 40 (+19.4)
• Readiness 15 → 43 (+27.3)
• Security 100 → 57 (-42.9)
• Accessibility 47 (new)

• Dependency hygiene not measured — no supported dependency manifest was read
• No tests found
• No tests — template/sample
• bus factor not measured — no commits were sampled
• early-stage repository — too little history to judge knowledge freshness
• single-commit history — no usable git history window to measure hotspots

• Analyzed solution does not cover the bulk of the repository
• Banned license: iTextSharp.LGPLv2.Core
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (micro-frontend/customer-frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (micro-frontend/customer-frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (micro-frontend/customer-frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (token-based-auth-core-react/ecommerce.client/package-lock.json)
• Critical CVE: [GHSA redacted] (micro-frontend/customer-frontend/package-lock.json)
• …and 137 more

• 163 added · 0 removed (a removed endpoint is potentially breaking)

• DELETE /api/accounts/{id}
• DELETE /api/bookings/{id}
• DELETE /api/catalogitem/delete/{id}
• DELETE /api/catalogitems/{id}
• DELETE /api/categories/{id}
• DELETE /api/customer/delete/{id}
• DELETE /api/customer/deletebulkdata
• DELETE /api/customer/deletecustomer/{id}
• DELETE /api/customer/{id}
• DELETE /api/customers/{id}
• DELETE /api/departments/{id}
• DELETE /api/district/{id}
• DELETE /api/documents/{id}
• DELETE /api/employee/deletebulkdata
• DELETE /api/employees/deleteemployee/{id}
• DELETE /api/employees/{id}
• DELETE /api/order/{id}
• DELETE /api/orders/delete/{id}
• DELETE /api/product/{id}
• DELETE /api/products/delete/{id}
• …and 143 more

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

mahedee/code-sample02 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.